Fix janky and drifty movement by switching to angle-based control

Major improvements to mouse movement quality:

1. **Fixed drift issue**: Changed from acceleration-based to angle-based control
   - Old: integrated acceleration → velocity → position (double integration = rapid drift)
   - New: use orientation angles (pitch/roll) directly for velocity
   - No more continuous drift when holding device still

2. **Fixed jankiness**: Added exponential smoothing filter
   - Smooths raw angle inputs with alpha=0.3 (30% new, 70% old)
   - Reduces jitter while maintaining responsiveness

3. **Better dead zone**: Applied to tilt angles instead of acceleration
   - Ignores tilts below 3 degrees (was 0.05g acceleration)
   - More effective at filtering unintentional movements

4. **Improved sensitivity**: Updated to 8.0 pixels/degree
   - Clear units: tilt angle → cursor speed
   - More intuitive tuning (was using acceleration units)

5. **Optimized AHRS fusion parameters**:
   - Reduced gain to 0.5 for better stability
   - Increased acceleration rejection to 20.0
   - Better suited for slow, deliberate tilt movements

Technical details:
- driver/src/uinput.c: Rewrite process_sensor_data() to use Euler angles
- driver/src/main.c: Update config defaults (sensitivity, dead_zone units)
- Movement now smooth, predictable, and drift-free

Author: claude

driver/src/main.c

@@ -12,9 +12,9 @@
 #include "uinput.h"
 
 MouseConfig config = {
-    .movement_sensitivity = 2.0f,       // Default: pixels per degree/second
+    .movement_sensitivity = 8.0f,       // Pixels per degree of tilt (higher = faster cursor)
     .scroll_sensitivity = 1.0f,
-    .dead_zone = 0.05f,                 // Default: degrees/second threshold for angular velocity  
+    .dead_zone = 3.0f,                  // Ignore tilts below 3 degrees (reduces jitter)
     .scroll_threshold = 0.3f,
     .invert_x = false,
     .invert_y = false,

driver/src/uinput.c

@@ -32,6 +32,7 @@ typedef struct {
     FusionAhrs ahrs;              // Fusion AHRS algorithm
     double t_last;
     float cursor_x, cursor_y;     // Virtual cursor position (accumulated)
+    float smoothed_vel_x, smoothed_vel_y;  // Smoothed cursor velocity
     int initialized;
 } FusionFilterState;
 
@@ -138,14 +139,14 @@ void process_sensor_data(UInputDevice* device, const SensorPacket* packet) {
         // Initialize Fusion AHRS
         FusionAhrsInitialise(&fusion_state.ahrs);
 
-        // Set AHRS settings optimized for fast, accurate mouse control
+        // Set AHRS settings optimized for tilt-based mouse control
         FusionAhrsSettings settings = {
             .convention = FusionConventionNwu,        // North-West-Up coordinate system
-            .gain = 1.0f,                            // Higher gain for faster convergence
+            .gain = 0.5f,                            // Moderate gain (balance speed vs stability)
             .gyroscopeRange = 2000.0f,               // ±2000 degrees/s range
-            .accelerationRejection = 10.0f,          // Lower rejection for mouse movements
+            .accelerationRejection = 20.0f,          // Moderate rejection (filter fast movements)
             .magneticRejection = 0.0f,               // No magnetometer
-            .recoveryTriggerPeriod = 2 * 200         // 2 seconds at 200Hz (faster recovery)
+            .recoveryTriggerPeriod = 5 * 50          // 5 seconds at 50Hz (don't recover too fast)
         };
         FusionAhrsSetSettings(&fusion_state.ahrs, &settings);
 
@@ -158,48 +159,43 @@ void process_sensor_data(UInputDevice* device, const SensorPacket* packet) {
     // Update AHRS with sensor data (no magnetometer)
     FusionAhrsUpdateNoMagnetometer(&fusion_state.ahrs, gyroscope, accelerometer, dt);
 
-    // Get current quaternion
+    // Get current orientation as Euler angles (roll, pitch, yaw)
     FusionQuaternion quaternion = FusionAhrsGetQuaternion(&fusion_state.ahrs);
-
-    // Get linear acceleration (with gravity removed by Fusion)
-    FusionVector linear_acceleration = FusionAhrsGetLinearAcceleration(&fusion_state.ahrs);
-
-    // Transform linear acceleration from device frame to world frame using current orientation
-    // This makes movement independent of device rotation - move device left = cursor left
-    FusionMatrix rotation_matrix = FusionQuaternionToMatrix(quaternion);
-    FusionVector world_acceleration = FusionMatrixMultiplyVector(rotation_matrix, linear_acceleration);
-
-    // Debug: log sensor fusion values
+    FusionEuler euler = FusionQuaternionToEuler(quaternion);
+
+    // Use orientation angles directly for cursor control
+    // Roll (tilting left/right) → X movement
+    // Pitch (tilting forward/back) → Y movement
+    // Yaw ignored (no magnetometer, drifts anyway)
+    float roll = euler.angle.roll;    // degrees
+    float pitch = euler.angle.pitch;  // degrees
+
+    // Apply dead zone to angles (filter small unintentional tilts)
+    float dead_zone_deg = config.dead_zone;  // e.g., 3.0 degrees
+    if (fabsf(roll) < dead_zone_deg) roll = 0.0f;
+    if (fabsf(pitch) < dead_zone_deg) pitch = 0.0f;
+
+    // Map tilt angles to cursor velocity (degrees → pixels/second)
+    // Larger tilt = faster cursor movement
+    float raw_vel_x = roll * config.movement_sensitivity;    // Roll → horizontal velocity
+    float raw_vel_y = pitch * config.movement_sensitivity;   // Pitch → vertical velocity
+
+    // Apply exponential smoothing to reduce jitter (alpha = 0.3 = 30% new, 70% old)
+    // Lower alpha = smoother but more lag, higher alpha = more responsive but jittery
+    float alpha = 0.3f;
+    fusion_state.smoothed_vel_x = alpha * raw_vel_x + (1.0f - alpha) * fusion_state.smoothed_vel_x;
+    fusion_state.smoothed_vel_y = alpha * raw_vel_y + (1.0f - alpha) * fusion_state.smoothed_vel_y;
+
+    // Integrate smoothed velocity to cursor position
+    fusion_state.cursor_x += fusion_state.smoothed_vel_x * dt;
+    fusion_state.cursor_y += fusion_state.smoothed_vel_y * dt;
+
+    // Debug: log orientation and velocity
     static int debug_count = 0;
-    if (++debug_count % 10 == 0) {  // Every 10 frames (~200ms)
-        FusionEuler euler = FusionQuaternionToEuler(quaternion);
-        syslog(LOG_INFO, "FUSION: Roll:%.1f° Pitch:%.1f° Yaw:%.1f° | WorldAccel(%.3f, %.3f, %.3f) dt:%.4f",
+    if (++debug_count % 10 == 0) {  // Every 10 frames (~200ms at 50Hz)
+        syslog(LOG_INFO, "Angles: Roll:%.1f° Pitch:%.1f° Yaw:%.1f° | Vel(%.1f, %.1f) px/s | dt:%.4f",
                euler.angle.roll, euler.angle.pitch, euler.angle.yaw,
-               world_acceleration.axis.x, world_acceleration.axis.y, world_acceleration.axis.z, dt);
-    }
-
-    // Apply dead zone to filter small movements (in g units)
-    float dead_zone_g = config.dead_zone;  // e.g., 0.03 g
-    if (fabsf(world_acceleration.axis.x) < dead_zone_g) world_acceleration.axis.x = 0.0f;
-    if (fabsf(world_acceleration.axis.y) < dead_zone_g) world_acceleration.axis.y = 0.0f;
-
-    // Map world-space acceleration to cursor velocity
-    // World X acceleration → horizontal cursor movement
-    // World Y acceleration → vertical cursor movement
-    // Z acceleration ignored (vertical in world frame)
-    float cursor_vel_x = world_acceleration.axis.x * config.movement_sensitivity;  // World X → Screen X
-    float cursor_vel_y = -world_acceleration.axis.y * config.movement_sensitivity; // World Y → Screen Y (inverted)
-
-    // Integrate velocity to position
-    fusion_state.cursor_x += cursor_vel_x * dt;
-    fusion_state.cursor_y += cursor_vel_y * dt;
-
-    // Debug velocity and accumulation
-    if (debug_count % 10 == 0) {
-        syslog(LOG_INFO, "VEL: (%.2f, %.2f) px/s | cursor_accum: (%.2f, %.2f) | sens:%.1f deadzone:%.3f g",
-               cursor_vel_x, cursor_vel_y,
-               fusion_state.cursor_x, fusion_state.cursor_y,
-               config.movement_sensitivity, dead_zone_g);
+               fusion_state.smoothed_vel_x, fusion_state.smoothed_vel_y, dt);
     }
 
     // Extract integer deltas for mouse movement
@@ -223,8 +219,8 @@ void process_sensor_data(UInputDevice* device, const SensorPacket* packet) {
     // Log periodically (every 50 packets ~1 second)
     static int log_count = 0;
     if (++log_count % 50 == 0) {
-        syslog(LOG_INFO, "FUSION Angular Vel: (%.2f, %.2f) | Cursor: (%.2f, %.2f) -> dx:%d dy:%d",
-               cursor_vel_x, cursor_vel_y,
+        syslog(LOG_INFO, "Movement: Vel(%.1f, %.1f) px/s | Accum(%.2f, %.2f) | Delta dx:%d dy:%d",
+               fusion_state.smoothed_vel_x, fusion_state.smoothed_vel_y,
                fusion_state.cursor_x, fusion_state.cursor_y,
                dx, dy);
     }