add some directives that seem necessary for debian

- 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

@@ -22,7 +22,7 @@ jobs:
     - 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
+      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 libproc2-dev
     - name: Set build dir
       id: strings
       shell: bash

CMakeLists.txt

@@ -1,7 +1,4 @@
-
-# minimum CMake version required for C++20 support, among other things
 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)
     set(MONOCOQUE_SUBPROJECT OFF)
@@ -20,9 +17,25 @@ 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)
+FIND_PACKAGE(Lua)
 set(INCLUDE_DIRS ${LUA_INCLUDE_DIR})
 include_directories(${LUA_INCLUDE_DIR})
+if(Lua_FOUND AND NOT TARGET Lua::Lua)
+  add_library(Lua::Lua INTERFACE IMPORTED)
+  set_target_properties(
+    Lua::Lua
+    PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${LUA_INCLUDE_DIR}"
+      INTERFACE_LINK_LIBRARIES "${LUA_LIBRARIES}"
+  )
+
+endif()
+message("Lua ${Lua_VERSION} found")
+if (Lua_VERSION VERSION_GREATER_EQUAL "5.5.0")
+    add_compile_definitions(USE_LUA_55)
+else()
+    remove_definitions(USE_LUA_55)
+endif()
 
 #FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
 #	HINTS $ENV{LIBUSB_ROOT}
@@ -39,14 +52,31 @@ set(BUILD_SHARED_LIBS TRUE) # HIDAPI as static library on all platforms
 
 add_executable(monocoque src/monocoque/monocoque.c)
 
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(LIBPROCPS libprocps)
+pkg_check_modules(LIBPROC2 libproc2)
+
+if (LIBPROCPS_FOUND)
+    #add_compile_definitions(USE_OLD_PID_VAL=0)
+elseif (LIBPROC2_FOUND)
+    if (LIBPROC2_VERSION VERSION_GREATER_EQUAL "4.0.5")
+        #add_compile_definitions(USE_OLD_PID_VAL=0)
+    else()
+        add_compile_definitions(USE_OLD_PID_VAL=1)
+    endif()
+else()
+    message(FATAL_ERROR "Either libprocps or libproc2 is required")
+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_link_libraries(monocoque m hidapi-hidraw pulse serialport xml2 argtable2 config gameloop helper devices slog simulatorapi uv xdg-basedir Lua::Lua proc2)
 
-target_include_directories(monocoque PUBLIC config ${LIBXML_INCLUDE_DIR})
+target_include_directories(monocoque PUBLIC config ${LIBXML_INCLUDE_DIR} ${LUA_INCLUDE_DIR})
 
 add_subdirectory(src/monocoque/gameloop)
 add_subdirectory(src/monocoque/simulatorapi)

README.md

@@ -41,6 +41,20 @@ chmod +x install.sh
 ./install.sh
 ```
 
+### Installation on Immutable Distros (Bazzite, Silverblue, etc.)
+
+On immutable distributions where native package managers are unavailable,
+monocoque can be installed inside a distrobox container:
+
+```bash
+bash tools/distro/distrobox/install-distrobox.sh
+```
+
+This creates an Arch Linux container, installs all packages via AUR, and sets up
+wrapper scripts (`start-simd`, `start-monocoque`, `test-monocoque`) in `~/.local/bin/`.
+
+To uninstall: `bash tools/distro/distrobox/uninstall-distrobox.sh`
+
 **TUI Manager:**
 After installation, use the interactive manager:
 ```bash
@@ -66,11 +80,12 @@ for installation instructions***
 - libconfig
 - xdg-basedir
 - lua
+- libproc2
 - [slog](https://github.com/kala13x/slog) (static)
 - [simshmbridge](https://github.com/spacefreak18/simshmbridge) - for sims that need shared memory mapping like AC and Project Cars related.
 - [simapi](https://github.com/spacefreak18/simapi)
 ```
-pacman -Syu git cmake pulse-native-provider libxdg-basedir libserialport libconfig libuv argtable hidapi lua
+pacman -Syu git cmake pulse-native-provider libxdg-basedir libserialport libconfig libuv argtable hidapi lua libproc2
 ```
 
 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:

conf/monocoque.config

@@ -220,6 +220,7 @@ configs = (
             config       = "None";
             baud         = 115200;
             devpath      = "/dev/simdev1";
+            fanpower     = 0.6;
         },
 
         {
@@ -228,6 +229,7 @@ configs = (
             config       = "None";
             baud         = 115200;
             devpath      = "/dev/simdev1";
+            fanpower     = 0.6;
         },
 
         {

install.sh

@@ -95,7 +95,7 @@ install_dependencies() {
     
     case $DISTRO in
         arch|manjaro)
-            local deps="yder libuv argtable libserialport libconfig hidapi lua libxdg-basedir mingw-w64-gcc"
+            local deps="yder libuv argtable libserialport libconfig hidapi lua54 libpulse pkgconfig libxdg-basedir mingw-w64-gcc"
             
             # Check if yay is available for AUR
             if command -v yay &> /dev/null; then
@@ -223,7 +223,7 @@ build_simapi() {
     
     mkdir -p build
     cd build
-    cmake ..
+    cmake -DINSTALL_SYSTEMD_SERVICE=off ..
     make -j$(nproc)
     
     log_info "Installing simapi library..."

src/arduino/simwind_pwm/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/simwind_pwm/simwind.h

@@ -0,0 +1,15 @@
+#ifndef _SIMWINDDATA_H
+#define _SIMWINDDATA_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct
+{
+    uint8_t velocity;
+    uint8_t fanpower;
+}
+SimWindData;
+
+
+#endif

src/arduino/simwind_pwm/simwind_pwm.ino

@@ -0,0 +1,56 @@
+#include "simwind.h"
+
+// ============================================================
+// Configuration
+// ============================================================
+#define BAUD_RATE       115200
+#define PWM_PIN_1       9       // Fan PWM output pins
+#define PWM_PIN_2       10      //
+#define PWM_MAX         320     // Max PWM value for 25kHz (16MHz / 25kHz / 2)
+#define SPEED_MIN       0       // Min speed (mph) — fans off below this
+#define SPEED_MAX       100     // Max speed (mph) — full fan speed at this
+#define SPEED_THRESHOLD 5       // Below this speed fans are off
+// ============================================================
+
+#define BYTE_SIZE sizeof(SimWindData)
+
+int velocity = 0;
+int fanpower = 0;
+
+void setup() {
+    Serial.begin(BAUD_RATE);
+
+    // Configure Timer1 for Phase Correct PWM at 25kHz duty cycle
+    // Mode 10: Phase Correct PWM, TOP = ICR1
+    // WGM13:WGM12:WGM11:WGM10 = 1:0:1:0
+    TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);
+    TCCR1B = _BV(WGM13) | _BV(CS10);   // <-- WGM13 restored, no prescaler
+    ICR1 = PWM_MAX;                      // TOP = 320 → 16MHz / (2 * 320) = 25kHz
+    pinMode(PWM_PIN_1, OUTPUT);
+    pinMode(PWM_PIN_2, OUTPUT);
+    OCR1A = 0;
+    OCR1B = 0;
+}
+
+void loop() {
+    char buff[BYTE_SIZE];
+    if (Serial.available() >= BYTE_SIZE) {
+        if (Serial.readBytes(buff, BYTE_SIZE) != BYTE_SIZE) return;
+        union { SimWindData data; char bytes[BYTE_SIZE]; } u;
+        memcpy(u.bytes, buff, BYTE_SIZE);
+        velocity = u.data.velocity;
+        fanpower = u.data.fanpower;
+    }
+
+    int pwm = 0;
+    if (velocity > SPEED_THRESHOLD) {
+        // Square root scaling for slightly stronger sensation at lower speeds
+        // fanpower (0-255) scales the overall intensity
+        float powerScale = (float)fanpower / 255.0;
+        pwm = (int)(sqrt((float)velocity / SPEED_MAX) * PWM_MAX * powerScale);
+        pwm = constrain(pwm, 0, PWM_MAX);
+    }
+
+    OCR1A = pwm;
+    OCR1B = pwm;
+}

src/monocoque/devices/CMakeLists.txt

@@ -42,6 +42,8 @@ set(devices_source_files
   serial/moza.c
   serial/moza_new.h
   serial/moza_new.c
+  serial/moza_ks_pro_wheel.h
+  serial/moza_ks_pro_wheel.c
 )
 
 include_directories("." "usb" "sound" "serial")

src/monocoque/devices/hapticeffect.c

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

src/monocoque/devices/serial/arduinoledlua.c

@@ -64,6 +64,39 @@ int simdata_to_lua(lua_State *L, SimData* simdata) {
     }
     lua_setfield(L, -2, "pd");
 
+    lua_pushnumber(L, simdata->gas);
+    lua_setfield(L, -2, "gas");
+
+    lua_pushnumber(L, simdata->fuel);
+    lua_setfield(L, -2, "fuel");
+
+    lua_pushnumber(L, simdata->turboboost);
+    lua_setfield(L, -2, "turboboost");
+
+    lua_newtable(L);
+    for(int i = 0; i < 4; i++)
+    {
+        lua_pushnumber(L, simdata->tyreRPS[i]);
+        lua_rawseti(L, -2, i+1);
+    }
+    lua_setfield(L, -2, "tyreRPS");
+
+    lua_newtable(L);
+    for(int i = 0; i < 4; i++)
+    {
+        lua_pushnumber(L, simdata->tyrediameter[i]);
+        lua_rawseti(L, -2, i+1);
+    }
+    lua_setfield(L, -2, "tyrediameter");
+
+    lua_newtable(L);
+    for(int i = 0; i < 4; i++)
+    {
+        lua_pushnumber(L, simdata->tyretemp[i]);
+        lua_rawseti(L, -2, i+1);
+    }
+    lua_setfield(L, -2, "tyretemp");
+
     return 0; // Return the table to Lua
 }
 

src/monocoque/devices/serial/arduinoledlua.h

@@ -1,9 +1,14 @@
 #ifndef _ARDUINOLEDLUA_H
 #define _ARDUINOLEDLUA_H
 
-#include "lua.h"
-#include "lauxlib.h"
-#include "lualib.h"
+//#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#ifdef USE_LUA_55
+/* open all libraries */
+#define luaL_openlibs(L)	luaL_openselectedlibs(L, ~0, 0)
+#endif
 
 #include "../../simulatorapi/simapi/simapi/simdata.h"
 

src/monocoque/devices/serial/moza.c

@@ -84,6 +84,8 @@ int moza_update(SerialDevice* serialdevice, unsigned short rpm, unsigned short m
 
 int moza_init(SerialDevice* serialdevice, const char* portdev)
 {
-    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
-    return serialdevice->id;
+    int id = monocoque_serial_open(serialdevice, portdev);
+    if (id < 0) return id;
+    serialdevice->id = id;
+    return 0;
 }

src/monocoque/devices/serial/moza_ks_pro_wheel.c

@@ -0,0 +1,142 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include <hidapi/hidapi.h>
+
+#include "moza.h"
+#include "moza_ks_pro_wheel.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, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0xff, 0, 0, 4, 0xff, 0, 0, 0}
+#define MOZA_RPM_COLOR_PAYLOAD_2 {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 5, 0xff, 0, 0, 6, 0xff, 0, 0, 7, 0xff, 0, 0, 8, 0xff, 0, 0, 9, 0xff, 0, 0, 0}
+#define MOZA_RPM_COLOR_PAYLOAD_3 {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 10, 0xff, 0x7f, 0, 11, 0xff, 0x7f, 0, 12, 0xff, 0x7f, 0, 13, 0, 0, 0xff, 14, 0, 0, 0xff, 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 MOZA_FLAG_COLOR_YELLOW_LEFT  {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 0, 0xff, 0xaa, 0, 1, 0xff, 0xaa, 0, 2, 0xff, 0xaa, 0, 0, 0xff, 0xaa, 0, 1, 0xff, 0xaa, 0, 0}
+#define MOZA_FLAG_COLOR_YELLOW_RIGHT {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 15, 0xff, 0xaa, 0, 16, 0xff, 0xaa, 0, 17, 0xff, 0xaa, 0, 15, 0xff, 0xaa, 0, 16, 0xff, 0xaa, 0, 0}
+#define MOZA_FLAG_COLOR_OFF_LEFT     {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}
+#define MOZA_FLAG_COLOR_OFF_RIGHT    {0x7e, 0x16, 0x3f, 0x17, 0x19, 0, 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, 0}
+#define BIT(nr) (1UL << (nr))
+
+int moza_ks_pro_wheel_update(SerialDevice* serialdevice, SimData* simData)
+{
+    static uint8_t last_flag = 0xff;
+    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(3);
+
+    if (perct >= 77)
+        bytes[6] |= BIT(4);
+
+    if (perct >= 79)
+        bytes[6] |= BIT(5);
+
+    if (perct >= 81)
+        bytes[6] |= BIT(6);
+
+    if (perct >= 83)
+        bytes[6] |= BIT(7);
+
+    if (perct >= 85)
+        bytes[7] |= BIT(0);
+
+    if (perct >= 87)
+        bytes[7] |= BIT(1);
+
+    if (perct >= 89)
+        bytes[7] |= BIT(2);
+
+    if (perct >= 91)
+        bytes[7] |= BIT(3);
+
+    if (perct >= 93)
+        bytes[7] |= BIT(4);
+
+    if (perct >= 95)
+        bytes[7] |= BIT(5);
+
+    if (perct >= 97)
+        bytes[7] |= BIT(6);
+
+
+    if (simData->playerflag == SIMAPI_FLAG_YELLOW) {
+        bytes[6] |= BIT(0) | BIT(1) | BIT(2);  // left 3 flag LEDs (indices 0, 1, 2)
+        bytes[7] |= BIT(7);                      // right flag LED (index 15)
+        bytes[8] |= BIT(0) | BIT(1);            // right flag LEDs (indices 16, 17)
+    }
+
+    bytes[10] = moza_checksum(bytes, size);
+
+    int result = 1;
+    if (serialdevice->port)
+    {
+        if (simData->playerflag != last_flag) {
+            last_flag = simData->playerflag;
+            if (simData->playerflag == SIMAPI_FLAG_YELLOW) {
+                unsigned char fl[] = MOZA_FLAG_COLOR_YELLOW_LEFT;
+                unsigned char fr[] = MOZA_FLAG_COLOR_YELLOW_RIGHT;
+                fl[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(fl, MOZA_COLOR_PAYLOAD_SIZE);
+                fr[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(fr, MOZA_COLOR_PAYLOAD_SIZE);
+                monocoque_serial_write(serialdevice->id, fl, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+                monocoque_serial_write(serialdevice->id, fr, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+            } else {
+                unsigned char fl[] = MOZA_FLAG_COLOR_OFF_LEFT;
+                unsigned char fr[] = MOZA_FLAG_COLOR_OFF_RIGHT;
+                fl[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(fl, MOZA_COLOR_PAYLOAD_SIZE);
+                fr[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(fr, MOZA_COLOR_PAYLOAD_SIZE);
+                monocoque_serial_write(serialdevice->id, fl, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+                monocoque_serial_write(serialdevice->id, fr, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+            }
+        }
+
+        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_ks_pro_wheel_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_RPM_COLOR_PAYLOAD_3;
+    unsigned char p4[] = MOZA_BTN_COLOR_PAYLOAD_1;
+    unsigned char p5[] = 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);
+    p5[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p5, 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);
+    monocoque_serial_write(serialdevice->id, p5, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+
+    unsigned char p6[] = MOZA_FLAG_COLOR_OFF_RIGHT;
+    p6[MOZA_COLOR_PAYLOAD_SIZE-1] = moza_checksum(p6, MOZA_COLOR_PAYLOAD_SIZE);
+    monocoque_serial_write(serialdevice->id, p6, MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+
+    return serialdevice->id;
+}

src/monocoque/devices/serial/moza_ks_pro_wheel.h

@@ -0,0 +1,10 @@
+#ifndef _MOZA_KS_PRO_WHEEL_H
+#define _MOZA_KS_PRO_WHEEL_H
+
+#include "../serialdevice.h"
+#include "../simdevice.h"
+
+int moza_ks_pro_wheel_update(SerialDevice* serialdevice, SimData* simData);
+int moza_ks_pro_wheel_init(SerialDevice* serialdevice, const char* portdev);
+
+#endif

src/monocoque/devices/serial/moza_new.c

@@ -74,8 +74,9 @@ int moza_new_update(SerialDevice* serialdevice, SimData* simData)
 
 int moza_new_init(SerialDevice* serialdevice, const char* portdev)
 {
-    serialdevice->id = monocoque_serial_open(serialdevice, portdev);
-    if (serialdevice->id == -1) return serialdevice->id;
+    int id = monocoque_serial_open(serialdevice, portdev);
+    if (id < 0) return id;
+    serialdevice->id = id;
 
     unsigned char p1[] = MOZA_RPM_COLOR_PAYLOAD_1;
     unsigned char p2[] = MOZA_RPM_COLOR_PAYLOAD_2;
@@ -87,10 +88,11 @@ int moza_new_init(SerialDevice* serialdevice, const char* portdev)
     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);
+    unsigned char* payloads[] = {p1, p2, p3, p4};
+    for (int i = 0; i < 4; i++) {
+        int result = monocoque_serial_write(serialdevice->id, payloads[i], MOZA_COLOR_PAYLOAD_SIZE, MOZA_TIMEOUT);
+        if (result < 0) return result;
+    }
 
-    return serialdevice->id;
+    return 0;
 }

src/monocoque/devices/serialadapter.c

@@ -27,10 +27,13 @@ int check(enum sp_return result)
             error_message = sp_last_error_message();
             sloge("error: serial write failed: %s", error_message);
             sp_free_error_message(error_message);
+            return result;
         case SP_ERR_SUPP:
             printf("Error: Not supported.\n");
+            return result;
         case SP_ERR_MEM:
             printf("Error: Couldn't allocate memory.\n");
+            return result;
         case SP_OK:
         default:
             return result;
@@ -114,23 +117,30 @@ int monocoque_input_wait(uint8_t serialdevicenum)
     return sp_input_waiting(monocoque_serial_dev.port);
 }
 
-int monocoque_serial_write(uint8_t serialdevicenum, void* data, size_t size, int timeout)
+// Helper function to get and validate device
+static monocoque_serial_device* monocoque_get_serial_device(uint8_t serialdevicenum)
 {
+    monocoque_serial_device* dev = &monocoque_serial_devices[serialdevicenum];
     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)
+    slogt("port name: %s, busy %i, open %i, openfail %i", dev->portname, dev->busy, dev->open, dev->openfail);
+    
+    if(dev->port == NULL)
     {
         sloge("port is null");
     }
+    
+    return dev;
+}
+
+int monocoque_serial_write(uint8_t serialdevicenum, void* data, size_t size, int timeout)
+{
+    monocoque_serial_device* dev = monocoque_get_serial_device(serialdevicenum);
 
     int result = -1;
-    if(monocoque_serial_dev.busy == false && monocoque_serial_dev.open == true)
+    if(dev->busy == false && dev->open == true)
     {
-        monocoque_serial_dev.busy = true;
-        result = sp_blocking_write(monocoque_serial_dev.port, data, size, timeout);
+        dev->busy = true;
+        result = sp_blocking_write(dev->port, data, size, timeout);
     }
     else
     {
@@ -138,67 +148,51 @@ int monocoque_serial_write(uint8_t serialdevicenum, void* data, size_t size, int
         result = -1;
     }
     slogt("write result is %i", result);
-    monocoque_serial_dev.busy = false;
+    dev->busy = false;
     return result;
 }
 
 int monocoque_serial_write_block(uint8_t serialdevicenum, void* data, size_t size, int timeout)
 {
-    slogt("serial device id %i", serialdevicenum);
-    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
-
-    slogt("port name: %s, busy %i, open %i, openfail %i", monocoque_serial_dev.portname, monocoque_serial_dev.busy, monocoque_serial_dev.open, monocoque_serial_dev.busy);
-
-    if(monocoque_serial_dev.port == NULL)
-    {
-        sloge("port is null");
-    }
+    monocoque_serial_device* dev = monocoque_get_serial_device(serialdevicenum);
 
     int result = -1;
-    if(monocoque_serial_dev.open == true)
+    if(dev->open == true)
     {
-        while(monocoque_serial_dev.busy == true)
+        while(dev->busy == true)
         {
             slogt("hopefully this doesn't happen long");
             continue;
         }
 
-        monocoque_serial_dev.busy = true;
-        result = sp_blocking_write(monocoque_serial_dev.port, data, size, timeout);
+        dev->busy = true;
+        result = sp_blocking_write(dev->port, data, size, timeout);
         slogi("actually performed write");
     }
 
-    monocoque_serial_dev.busy = false;
+    dev->busy = false;
     return result;
 }
 
 int monocoque_serial_read_block(uint8_t serialdevicenum, void* data, size_t size, int timeout)
 {
-    slogt("serial device id %i", serialdevicenum);
-    monocoque_serial_device monocoque_serial_dev = monocoque_serial_devices[serialdevicenum];
-
-    slogt("port name: %s, busy %i, open %i, openfail %i", monocoque_serial_dev.portname, monocoque_serial_dev.busy, monocoque_serial_dev.open, monocoque_serial_dev.busy);
-
-    if(monocoque_serial_dev.port == NULL)
-    {
-        sloge("port is null");
-    }
+    monocoque_serial_device* dev = monocoque_get_serial_device(serialdevicenum);
 
     int result = -1;
-    if(monocoque_serial_dev.open == true)
+    if(dev->open == true)
     {
-        while(monocoque_serial_dev.busy == true)
+        while(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);
+        dev->busy = true;
+        result = sp_blocking_read(dev->port, data, size, timeout);
         slogi("actually performed read");
     }
 
-    monocoque_serial_dev.busy = false;
+    dev->busy = false;
     return result;
 }
 

src/monocoque/devices/serialdevice.c

@@ -11,6 +11,7 @@
 #include "serial/arduino.h"
 #include "serial/moza.h"
 #include "serial/moza_new.h"
+#include "serial/moza_ks_pro_wheel.h"
 #include "../helper/parameters.h"
 #include "../simulatorapi/simapi/simapi/simdata.h"
 #include "../slog/slog.h"
@@ -26,6 +27,10 @@ int serial_wheel_update(SimDevice* this, SimData* simdata)
         moza_new_update(serialdevice, simdata);
         break;
 
+      case SERIALDEV__MOZA_KS_PRO_WHEEL:
+        moza_ks_pro_wheel_update(serialdevice, simdata);
+        break;
+
       case SIMDEVSUBTYPE_MOZAR5:
       default:
         moza_update(serialdevice, simdata->rpms, simdata->maxrpm);
@@ -118,8 +123,9 @@ int arduino_simwind_update(SimDevice* this, SimData* simdata)
     serialdevice->u.simwinddata.velocity = ceil(simdata->velocity*KPHTOMPH);
 
     slogt("Updating arduino device speed to %i", serialdevice->u.simwinddata.velocity);
-    // this can be added to the config, all config dependent can be added to init
-    serialdevice->u.simwinddata.fanpower = (int)0.6 * 255;
+
+    serialdevice->u.simwinddata.fanpower = (int)(serialdevice->fanpower * 255);
+    slogt("Sending fanpower: %i (from config: %f)", serialdevice->u.simwinddata.fanpower, serialdevice->fanpower);
     size_t size = sizeof(SimWindData);
 
     arduino_update(serialdevice, &serialdevice->u.simwinddata, size);
@@ -219,7 +225,7 @@ int serial_wheel_free(SimDevice* this)
     return 0;
 }
 
-int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
+int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds, SimInfo* siminfo)
 {
     slogi("initializing serial device on port %s to %i...", ds->serialdevsettings.portdev, ds->serialdevsettings.baud);
     int error = 0;
@@ -239,6 +245,9 @@ int serialdev_init(SerialDevice* serialdevice, DeviceSettings* ds)
         case SERIALDEV__MOZA_NEW:
             error = moza_new_init(serialdevice, ds->serialdevsettings.portdev);
             break;
+        case SERIALDEV__MOZA_KS_PRO_WHEEL:
+            error = moza_ks_pro_wheel_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);
@@ -276,7 +285,7 @@ static const vtable arduino_simwind_vtable = { &arduino_simwind_update, &seriald
 static const vtable arduino_simhaptic_vtable = { &arduino_simhaptic_update, &serialdev_free };
 static const vtable serialwheel_vtable = { &serial_wheel_update, &serial_wheel_free };
 
-SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
+SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo) {
 
     SerialDevice* this = (SerialDevice*) malloc(sizeof(SerialDevice));
 
@@ -285,6 +294,7 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
     this->m.derived = this;
     this->m.vtable = &serial_simdevice_vtable;
     this->type = SERIALDEV_ARDUINO;
+    int error = 0;
 
     slogt("Attempting to configure arduino device with subtype: %i", ds->dev_subtype);
     switch (ds->dev_subtype) {
@@ -317,7 +327,8 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
         case (SIMDEVTYPE_SIMWIND):
             this->devicetype = ARDUINODEV__SIMWIND;
             this->m.vtable = &arduino_simwind_vtable;
-            slogi("Initializing arduino devices for sim wind.");
+            this->fanpower = ds->serialdevsettings.fanpower;
+            slogi("Initializing arduino devices for sim wind with fanpower: %f", this->fanpower);
             break;
         case (SIMDEVTYPE_ARDUINOCUSTOM):
             this->devicetype = ARDUINODEV__CUSTOM;
@@ -325,6 +336,10 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             slogi("Initializing custom arduino device.");
             break;
         case (SIMDEVTYPE_SERIALHAPTIC):
+            if(siminfo->SimSupportsHapticEffects == false)
+            {
+                error = MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE;
+            }
             this->devicetype = ARDUINODEV__HAPTIC;
             this->m.vtable = &arduino_simhaptic_vtable;
             this->u.simhapticdata.motor1 = 0;
@@ -337,6 +352,7 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             this->u.simhapticdata.effect4 = 0;
             this->state = 0;
             this->ampfactor = ds->serialdevsettings.ampfactor;
+            this->fanpower = ds->serialdevsettings.fanpower;
             slogi("Initializing arduino device for haptic effects.");
             break;
         case (SIMDEVTYPE_SERIALWHEEL):
@@ -349,6 +365,11 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
                   this->devicetype = SERIALDEV__MOZA_NEW;
                   this->m.vtable = &serialwheel_vtable;
                   break;
+                case SIMDEVSUBTYPE_MOZA_KS_PRO_WHEEL:
+                  slogi("Initializing new firmware Moza serial wheel device.");
+                  this->devicetype = SERIALDEV__MOZA_KS_PRO_WHEEL;
+                  this->m.vtable = &serialwheel_vtable;
+                  break;
                 case SIMDEVSUBTYPE_MOZAR5:
                 default:
                   //move this stuff to wheeldevice or it's own serial wheel device module
@@ -359,7 +380,7 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
             }
     }
 
-    if(this->devicetype == ARDUINODEV__HAPTIC)
+    if(this->devicetype == ARDUINODEV__HAPTIC && error == 0)
     {
         this->m.hapticeffect.threshold = ds->threshold;
         this->m.hapticeffect.effecttype = ds->effect_type;
@@ -370,10 +391,15 @@ SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms) {
         this->m.hapticeffect.tyrediameterconfig = ms->tyre_diameter_config;
     }
 
-    int error = serialdev_init(this, ds);
-
-    if (error < 0)
+    if(error == 0)
     {
+        slogi("Starting serial device initialization");
+        error = serialdev_init(this, ds, siminfo);
+    }
+
+    if (error != 0)
+    {
+        slogw("Did not initialize usb device due to error code %i", error);
         free(this);
         return NULL;
     }

src/monocoque/devices/serialdevice.h

@@ -13,7 +13,8 @@ typedef enum
     ARDUINODEV__SIMLED                = 4,
     ARDUINODEV__SIMLED__CUSTOM        = 5,
     ARDUINODEV__CUSTOM                = 6,
-    SERIALDEV__MOZA_NEW               = 7
+    SERIALDEV__MOZA_NEW               = 7,
+    SERIALDEV__MOZA_KS_PRO_WHEEL      = 8
 }
 SerialDeviceType;
 

src/monocoque/devices/simdevice.c

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

src/monocoque/devices/simdevice.h

@@ -4,7 +4,7 @@
 #include <stdbool.h>
 #include <hidapi/hidapi.h>
 
-#include "lua.h"
+#include <lua.h>
 
 #include "usbdevice.h"
 #include "sounddevice.h"
@@ -66,6 +66,7 @@ typedef struct
     int endled;
     int baudrate;
     double ampfactor;
+    double fanpower;
     double state;
     union
     {
@@ -82,7 +83,7 @@ int arduino_simwind_update(SimDevice* this, SimData* simdata);
 int arduino_simhaptic_update(SimDevice* this, SimData* simdata);
 int serialdev_free(SimDevice* this);
 
-SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms);
+SerialDevice* new_serial_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 /********* USB HID Devices *****/
 typedef enum
@@ -112,7 +113,7 @@ USBDevice;
 int usbdev_update(SimDevice* this, SimData* simdata);
 int usbdev_free(SimDevice* this);
 
-USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms);
+USBDevice* new_usb_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 
 /********* Sound Devices *****/
@@ -137,7 +138,7 @@ int sounddev_gearshift_update(SimDevice* this, SimData* simdata);
 int sounddev_tyreslip_update(SimDevice* this, SimData* simdata);
 int sounddev_free(SimDevice* this);
 
-SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms);
+SoundDevice* new_sound_device(DeviceSettings* ds, MonocoqueSettings* ms, SimInfo* siminfo);
 
 /***** Generic Methods *********/
 
@@ -145,7 +146,7 @@ int update(SimDevice* simdevice, SimData* simdata);
 
 int devupdate(SimDevice* simdevice, SimData* simdata);
 
-int devinit(SimDevice* simdevices, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms);
+int devinit(SimDevice* simdevices, SimInfo* siminfo, int numdevices, DeviceSettings* ds, MonocoqueSettings* ms);
 
 int devfree(SimDevice* simdevices, int numdevices);
 

src/monocoque/devices/sounddevice.c

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

src/monocoque/devices/usbdevice.c

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

src/monocoque/devices/usbhapticdevice.c

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

src/monocoque/devices/usbhapticdevice.h

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

src/monocoque/gameloop/gameloop.c

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

src/monocoque/gameloop/loopdata.h

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

src/monocoque/helper/confighelper.c

@@ -113,6 +113,16 @@ int strtodevsubsubtype(const char* device_subsubtype, DeviceSettings* ds)
         ds->dev_subsubtype = SIMDEVSUBTYPE_MOZAR5;
         devfound = true;
     }
+    if (strcicmp(device_subsubtype, "MozaR3") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_MOZAR5;
+        devfound = true;
+    }
+    if (strcicmp(device_subsubtype, "MozaKSProWheel") == 0)
+    {
+        ds->dev_subsubtype = SIMDEVSUBTYPE_MOZA_KS_PRO_WHEEL;
+        devfound = true;
+    }
     if (strcicmp(device_subsubtype, "CSLELITEV3PEDALS") == 0)
     {
         ds->dev_subsubtype = SIMDEVSUBTYPE_CSLELITEV3PEDALS;
@@ -710,7 +720,7 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
         }
     }
 
-    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC || ds->dev_subtype == SIMDEVTYPE_USBWHEEL)
+    if (ds->dev_subtype == SIMDEVTYPE_USBHAPTIC || ds->dev_subtype == SIMDEVTYPE_USBWHEEL || ds->dev_subtype == SIMDEVTYPE_SERIALWHEEL)
     {
         // logic for different devices
         int b = 0;
@@ -861,7 +871,11 @@ int devsetup(const char* device_type, const char* device_subtype, const char* co
             found = config_setting_lookup_float(device_settings, "ampfactor", &ampfactor);
             ds->serialdevsettings.ampfactor = ampfactor;
 
-            slogt("set port baud rate to %i, ampfactor %f", baud, ampfactor);
+            double fanpower = 0.6;
+            config_setting_lookup_float(device_settings, "fanpower", &fanpower);
+            ds->serialdevsettings.fanpower = fanpower;
+
+            slogt("set port baud rate to %i, ampfactor %f, fanpower %f", baud, ampfactor, fanpower);
 
         }
 

src/monocoque/helper/confighelper.h

@@ -45,7 +45,8 @@ typedef enum
     SIMDEVSUBTYPE_SIMAGICP1000PEDALS      = 5,
     SIMDEVSUBTYPE_SIMAGICGTNEO            = 6,
     SIMDEVSUBTYPE_MOZA_NEW                = 7,
-    SIMDEVSUBTYPE_LOGITECH_G29            = 8
+    SIMDEVSUBTYPE_LOGITECH_G29            = 8,
+    SIMDEVSUBTYPE_MOZA_KS_PRO_WHEEL       = 9
 }
 DeviceSubSubType;
 
@@ -109,12 +110,13 @@ MonocoqueGear;
 
 typedef enum
 {
-    MONOCOQUE_ERROR_NONE          = 0,
-    MONOCOQUE_ERROR_UNKNOWN       = 1,
-    MONOCOQUE_ERROR_INVALID_SIM   = 2,
-    MONOCOQUE_ERROR_INVALID_DEV   = 3,
-    MONOCOQUE_ERROR_NODATA        = 4,
-    MONOCOQUE_ERROR_UNKNOWN_DEV   = 5
+    MONOCOQUE_ERROR_NONE                     = 0,
+    MONOCOQUE_ERROR_UNKNOWN                  = 1,
+    MONOCOQUE_ERROR_INVALID_SIM              = 2,
+    MONOCOQUE_ERROR_INVALID_DEV              = 3,
+    MONOCOQUE_ERROR_NODATA                   = 4,
+    MONOCOQUE_ERROR_UNKNOWN_DEV              = 5,
+    MONOCOQUE_ERROR_UNSUPPORTED_SIM_FEATURE  = 6,
 }
 MonocoqueError;
 
@@ -167,6 +169,7 @@ typedef struct
     int startled;
     int endled;
     float ampfactor;
+    float fanpower;
     int baud;
 }
 SerialDeviceSettings;

src/monocoque/monocoque.c

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

src/monocoque/simulatorapi/CMakeLists.txt

@@ -40,7 +40,6 @@ set(simulatorapi_source_files
   simapi/simapi/mapping/wreckfest2mapper.c
   simapi/simapi/mapping/forzamapper.c
   simapi/simapi/getpid.c
-  simapi/simapi/getpid.h
 )
 
 add_library(simulatorapi STATIC ${simulatorapi_source_files})

tools/distro/distrobox/install-distrobox.sh

@@ -0,0 +1,254 @@
+#!/bin/bash
+# Monocoque Distrobox Installer
+# For immutable Linux distributions (Bazzite, Silverblue, etc.)
+# where native package managers are unavailable.
+#
+# Installs monocoque and dependencies inside an Arch Linux distrobox container,
+# with wrapper scripts on the host for transparent access.
+
+set -euo pipefail
+
+SCRIPT_VERSION="1.0.0"
+CONTAINER="simracing"
+INSTALL_DIR="$HOME/.local/share/simracing"
+BIN_DIR="$HOME/.local/bin"
+CONFIG_DIR="$HOME/.config/monocoque"
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+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 Distrobox Installer v${SCRIPT_VERSION}        ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo ""
+}
+
+# --- Main ---
+
+print_header
+
+# Check ~/.local/bin is in PATH
+if [[ ":$PATH:" != *":$BIN_DIR:"* ]]; then
+    log_error "$BIN_DIR is not in your PATH."
+    log_info "Add this to your shell config:"
+    echo "    export PATH=\"\$HOME/.local/bin:\$PATH\""
+    exit 1
+fi
+
+# Check distrobox is available
+if ! command -v distrobox &>/dev/null; then
+    log_error "distrobox is not installed."
+    log_info "Install distrobox first: https://distrobox.it/#installation"
+    exit 1
+fi
+
+# Ensure dialout group exists and user is a member
+log_info "Checking serial device access (dialout group)..."
+if ! grep -q '^dialout:' /etc/group 2>/dev/null; then
+    if grep -q '^dialout:' /usr/lib/group 2>/dev/null; then
+        log_info "Adding dialout group to /etc/group (Fedora Atomic fix)..."
+        grep -E '^dialout:' /usr/lib/group | sudo tee -a /etc/group >/dev/null
+    else
+        log_info "Creating dialout group..."
+        sudo groupadd dialout
+    fi
+fi
+if ! groups | grep -qw dialout; then
+    log_info "Adding $USER to the dialout group for serial device access..."
+    sudo usermod -aG dialout "$USER"
+    log_warn "You will need to REBOOT after setup completes for serial access to work."
+    echo ""
+fi
+
+# Prevent ModemManager from grabbing Moza serial devices
+UDEV_RULE="/etc/udev/rules.d/99-moza-serial.rules"
+if [ ! -f "$UDEV_RULE" ]; then
+    if systemctl is-active --quiet ModemManager 2>/dev/null; then
+        echo ""
+        log_warn "ModemManager is running on your system."
+        echo "  Moza wheel bases use USB serial devices that ModemManager may claim,"
+        echo "  preventing monocoque from communicating with the wheel."
+        echo ""
+        echo "  A udev rule can tell ModemManager to ignore Moza devices (vendor 346e)."
+        echo "  This only affects Moza USB devices — other modems will work normally."
+        echo ""
+        read -rp "Install udev rule to prevent ModemManager from grabbing Moza devices? [Y/n]: " mm_confirm
+        if [[ "$mm_confirm" =~ ^[Nn]$ ]]; then
+            echo ""
+            log_info "Skipped udev rule. If monocoque can't talk to your wheel, run:"
+            echo "  sudo tee $UDEV_RULE <<< 'ACTION==\"add|change\", SUBSYSTEM==\"usb\", ATTR{idVendor}==\"346e\", ENV{ID_MM_DEVICE_IGNORE}=\"1\"'"
+            echo "  sudo udevadm control --reload-rules && sudo udevadm trigger"
+            echo ""
+        else
+            log_info "Installing udev rule..."
+            echo 'ACTION=="add|change", SUBSYSTEM=="usb", ATTR{idVendor}=="346e", ENV{ID_MM_DEVICE_IGNORE}="1"' | sudo tee "$UDEV_RULE" >/dev/null
+            sudo udevadm control --reload-rules
+            sudo udevadm trigger
+            log_success "ModemManager udev rule installed"
+        fi
+    else
+        # ModemManager not running — install the rule silently
+        echo 'ACTION=="add|change", SUBSYSTEM=="usb", ATTR{idVendor}=="346e", ENV{ID_MM_DEVICE_IGNORE}="1"' | sudo tee "$UDEV_RULE" >/dev/null
+        sudo udevadm control --reload-rules
+        sudo udevadm trigger
+    fi
+fi
+
+# Create the Arch Linux distrobox container
+if ! distrobox list 2>/dev/null | grep -q "$CONTAINER"; then
+    log_info "Creating Arch Linux container '$CONTAINER'..."
+    distrobox create \
+        --image docker.io/library/archlinux:latest \
+        --name "$CONTAINER" \
+        --pre-init-hooks "sed -i 's/^SigLevel.*/SigLevel = Never/' /etc/pacman.conf && pacman -Sy --noconfirm archlinux-keyring && pacman-key --init && pacman-key --populate archlinux && sed -i 's/^SigLevel.*/SigLevel = Required DatabaseOptional/' /etc/pacman.conf"
+    log_success "Container '$CONTAINER' created"
+else
+    log_info "Container '$CONTAINER' already exists, skipping creation."
+fi
+
+# Install packages inside the container
+log_info "Installing packages inside container (this may take a few minutes)..."
+distrobox enter "$CONTAINER" -- bash -c '
+    set -euo pipefail
+
+    # Install build dependencies
+    echo "Installing build dependencies..."
+    sudo pacman -Syu --needed --noconfirm base-devel git mingw-w64-gcc
+
+    # Install yay (AUR helper) if not present
+    if ! command -v yay &>/dev/null; then
+        echo "Installing yay AUR helper..."
+        TMPDIR=$(mktemp -d)
+        git clone https://aur.archlinux.org/yay-bin.git "$TMPDIR/yay-bin"
+        cd "$TMPDIR/yay-bin"
+        makepkg -si --noconfirm
+        cd /
+        rm -rf "$TMPDIR"
+    fi
+
+    # Install AUR packages sequentially (simd depends on simapi, monocoque depends on both)
+    echo "Installing AUR packages..."
+    yay -S --needed --noconfirm simapi-git
+    yay -S --needed --noconfirm simd-git
+    yay -S --needed --noconfirm monocoque-git
+
+    # Build simshmbridge (not on AUR)
+    INSTALL_DIR="$HOME/.local/share/simracing"
+    mkdir -p "$INSTALL_DIR"
+    cd "$INSTALL_DIR"
+    if [ ! -d "simshmbridge" ]; then
+        echo "Cloning simshmbridge..."
+        git clone --recurse-submodules "https://github.com/Spacefreak18/simshmbridge.git"
+    else
+        echo "simshmbridge already cloned, pulling latest..."
+        cd simshmbridge && git pull && git submodule update --init --recursive && cd ..
+    fi
+    echo "Building simshmbridge..."
+    cd "$INSTALL_DIR/simshmbridge"
+    git submodule update --init --recursive
+    make clean 2>/dev/null || true
+    make -j$(nproc)
+
+    echo ""
+    echo "All components built successfully inside container."
+'
+
+# Install wrapper scripts to ~/.local/bin
+log_info "Installing wrapper scripts..."
+mkdir -p "$BIN_DIR"
+
+cat > "$BIN_DIR/start-simd" << 'EOF'
+#!/usr/bin/env bash
+exec distrobox enter simracing -- simd "$@"
+EOF
+chmod +x "$BIN_DIR/start-simd"
+
+cat > "$BIN_DIR/start-monocoque" << 'EOF'
+#!/usr/bin/env bash
+exec distrobox enter simracing -- monocoque play "$@"
+EOF
+chmod +x "$BIN_DIR/start-monocoque"
+
+cat > "$BIN_DIR/test-monocoque" << 'EOF'
+#!/usr/bin/env bash
+exec distrobox enter simracing -- monocoque test -vv "$@"
+EOF
+chmod +x "$BIN_DIR/test-monocoque"
+
+log_success "Wrapper scripts installed"
+
+# Setup monocoque config
+mkdir -p "$CONFIG_DIR"
+if [ ! -f "$CONFIG_DIR/monocoque.config" ]; then
+    log_info "Creating monocoque config template..."
+    cat > "$CONFIG_DIR/monocoque.config" << 'EOF'
+configs = (
+    {
+        sim = "default";
+        car = "default";
+        devices = (
+        {
+            device       = "Serial";
+            type         = "Wheel";
+            subtype      = "MozaNew";
+            devpath      = "/dev/serial/by-id/CHANGE_ME_TO_YOUR_MOZA_BASE";
+            baud         = 115200;
+        });
+    }
+);
+EOF
+    log_success "Config created at $CONFIG_DIR/monocoque.config"
+else
+    log_info "Config already exists, skipping"
+fi
+
+# Done
+echo ""
+echo "╔══════════════════════════════════════════════════════════════════╗"
+echo "║                  Installation Complete!                          ║"
+echo "╚══════════════════════════════════════════════════════════════════╝"
+echo ""
+log_success "Monocoque (distrobox) installed!"
+echo ""
+echo "  Installed:"
+echo "    AUR packages:  simapi-git, simd-git, monocoque-git (in '$CONTAINER' container)"
+echo "    Bridge:        $INSTALL_DIR/simshmbridge/"
+echo "    Config:        $CONFIG_DIR/monocoque.config"
+echo "    Commands:      start-simd, start-monocoque, test-monocoque"
+echo ""
+echo "  Next steps:"
+echo "    1. Set your device path in $CONFIG_DIR/monocoque.config"
+echo "       (replace CHANGE_ME_TO_YOUR_MOZA_BASE with your device from /dev/serial/by-id/)"
+echo "    2. Test with: test-monocoque"
+echo "    3. Set Steam launch options for your games to start the telemetry stack automatically:"
+echo "       In Steam > Game Properties > Launch Options, add:"
+echo "         start-simd & start-monocoque & <bridge_path> %command%"
+echo "       For example, for Assetto Corsa:"
+echo "         start-simd & start-monocoque & $INSTALL_DIR/simshmbridge/assets/acbridge.exe %command%"
+echo ""
+echo "  For tools that automate steps 1 and 3 (Moza auto-detection, Steam launch"
+echo "  option configuration, unified game launcher), visit:"
+echo "    https://github.com/cescofry/simracing-utilities"
+echo ""

tools/distro/distrobox/uninstall-distrobox.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# Monocoque Distrobox Uninstaller
+# Removes the distrobox-based monocoque installation.
+
+set -euo pipefail
+
+CONTAINER="simracing"
+BIN_DIR="$HOME/.local/bin"
+INSTALL_DIR="$HOME/.local/share/simracing"
+CONFIG_DIR="$HOME/.config/monocoque"
+UDEV_RULE="/etc/udev/rules.d/99-moza-serial.rules"
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+print_header() {
+    echo ""
+    echo "╔══════════════════════════════════════════════════════════════════╗"
+    echo "║                Monocoque Distrobox Uninstaller                   ║"
+    echo "╚══════════════════════════════════════════════════════════════════╝"
+    echo ""
+}
+
+print_header
+
+log_warn "This will remove:"
+echo "  - Distrobox container '$CONTAINER'"
+echo "  - Wrapper scripts ($BIN_DIR/start-simd, start-monocoque, test-monocoque)"
+echo "  - simshmbridge source ($INSTALL_DIR)"
+echo ""
+echo "This will NOT remove:"
+echo "  - Configuration files ($CONFIG_DIR)"
+echo "  - Convenience scripts (simracing-launch, configure-moza, etc.)"
+echo ""
+
+read -rp "Continue with uninstallation? [y/N]: " confirm
+if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
+    log_info "Uninstallation cancelled"
+    exit 0
+fi
+
+echo ""
+
+# Remove wrapper scripts
+log_info "Removing wrapper scripts..."
+rm -f "$BIN_DIR/start-simd"
+rm -f "$BIN_DIR/start-monocoque"
+rm -f "$BIN_DIR/test-monocoque"
+log_success "Wrapper scripts removed"
+
+# Remove simshmbridge source
+if [ -d "$INSTALL_DIR" ]; then
+    log_info "Removing simshmbridge source..."
+    rm -rf "$INSTALL_DIR"
+    log_success "simshmbridge source removed"
+fi
+
+# Remove distrobox container
+if distrobox list 2>/dev/null | grep -q "$CONTAINER"; then
+    log_info "Removing distrobox container '$CONTAINER'..."
+    distrobox rm --force "$CONTAINER"
+    log_success "Container '$CONTAINER' removed"
+else
+    log_info "Container '$CONTAINER' not found, skipping"
+fi
+
+# Optionally remove udev rule
+if [ -f "$UDEV_RULE" ]; then
+    echo ""
+    read -rp "Remove ModemManager udev rule ($UDEV_RULE)? [y/N]: " remove_udev
+    if [[ "$remove_udev" =~ ^[Yy]$ ]]; then
+        sudo rm -f "$UDEV_RULE"
+        sudo udevadm control --reload-rules
+        sudo udevadm trigger
+        log_success "udev rule removed"
+    else
+        log_info "Keeping udev rule"
+    fi
+fi
+
+echo ""
+log_success "Uninstallation complete!"
+echo ""
+log_info "Config files preserved at $CONFIG_DIR"
+echo "  To remove those too: rm -rf $CONFIG_DIR"
+echo ""

tools/distro/fedora/rpm/fedora.spec

@@ -1,4 +1,4 @@
-#dnf install pulseaudio-libs-devel argtable-devel libconfig-devel hidapi-devel libserialport-devel lua-devel libuv-devel libxdg-basedir-devel libxml2-devel
+#dnf install pulseaudio-libs-devel argtable-devel libconfig-devel hidapi-devel libserialport-devel lua-devel libuv-devel libxdg-basedir-devel libxml2-devel procps-ng-devel
 Summary: A device manager for racing sims
 Name: monocoque
 Version: 0.0.5
@@ -10,7 +10,7 @@ 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
+Requires: pulseaudio-libs argtable libconfig hidapi libserialport libuv libxdg-basedir lua-libs libxml2 procps-ng
 
 %description
 A device manager for Racing sims