fw: Add Motion Sensitivity setting and LSM6DSO mapping

Add an Asterix-only settings menu and preference (0-100%, default 100%)
to control accelerometer shake sensitivity. Expose shell prefs and UI
labels, and store the value in prefs_values. Introduce
accel_manager_update_sensitivity and a driver API to set percent. Driver
interpolates between board low/high wake thresholds (100% = most
sensitive = low threshold), clamps values, logs changes, and
reconfigures shake detection immediately.

Signed-off-by: Joshua Jun <joshuajun@proton.me>

Author: jplexer

src/fw/apps/system_apps/settings/settings_system.c

@@ -16,6 +16,7 @@
 
 #include "settings_factory_reset.h"
 #include "settings_menu.h"
+#include "settings_option_menu.h"
 #include "settings_system.h"
 #include "settings_window.h"
 
@@ -75,6 +76,9 @@ enum {
   DebuggingItemCoreDumpNow = 0,
   DebuggingItemCoreDumpShortcut,
   DebuggingItemALSThreshold,
+#if PLATFORM_ASTERIX
+  DebuggingItemMotionSensitivity,
+#endif
   DebuggingItem_Count,
 };
 
@@ -464,13 +468,61 @@ static void prv_als_threshold_menu_push(SettingsSystemData *data) {
   app_window_stack_push(&number_window->window, animated);
 }
 
+// Motion Sensitivity Settings (Asterix/Obelix only)
+/////////////////////////////
+#if PLATFORM_ASTERIX
+static const uint8_t s_motion_sensitivity_values[] = { 10, 25, 40, 55, 70, 85, 100 };
+
+static const char *s_motion_sensitivity_labels[] = {
+  i18n_noop("Very Low"),
+  i18n_noop("Low"),
+  i18n_noop("Medium-Low"),
+  i18n_noop("Medium"),
+  i18n_noop("Medium-High"),
+  i18n_noop("High"),
+  i18n_noop("Very High")
+};
+
+static int prv_motion_sensitivity_get_selection_index() {
+  const uint8_t sensitivity = shell_prefs_get_motion_sensitivity();
+  
+  // Find closest match
+  for (int i = 0; i < (int)ARRAY_LENGTH(s_motion_sensitivity_values); i++) {
+    if (sensitivity <= s_motion_sensitivity_values[i]) {
+      return i;
+    }
+  }
+  return ARRAY_LENGTH(s_motion_sensitivity_values) - 1;
+}
+
+static void prv_motion_sensitivity_menu_select(OptionMenu *option_menu, int selection, void *context) {
+  shell_prefs_set_motion_sensitivity(s_motion_sensitivity_values[selection]);
+  app_window_stack_remove(&option_menu->window, true /* animated */);
+}
+
+static void prv_motion_sensitivity_menu_push(SettingsSystemData *data) {
+  int index = prv_motion_sensitivity_get_selection_index();
+  const OptionMenuCallbacks callbacks = {
+    .select = prv_motion_sensitivity_menu_select,
+  };
+  const char *title = i18n_noop("Motion Sensitivity");
+  settings_option_menu_push(
+      title, OptionMenuContentType_SingleLine, index, &callbacks,
+      ARRAY_LENGTH(s_motion_sensitivity_labels),
+      true /* icons_enabled */, s_motion_sensitivity_labels, data);
+}
+#endif
+
 // Debug options window
 ///////////////////////
 
 static const char* s_debugging_titles[DebuggingItem_Count] = {
   [DebuggingItemCoreDumpNow]      = i18n_noop("Bug report now"),
   [DebuggingItemCoreDumpShortcut] = i18n_noop("Bug shortcut"),
   [DebuggingItemALSThreshold]     = i18n_noop("ALS Threshold"),
+#if PLATFORM_ASTERIX
+  [DebuggingItemMotionSensitivity] = i18n_noop("Motion Sensitivity"),
+#endif
 };
 
 static void prv_debugging_draw_row_callback(GContext* ctx, const Layer *cell_layer,
@@ -497,6 +549,11 @@ static void prv_debugging_draw_row_callback(GContext* ctx, const Layer *cell_lay
              "%"PRIu32, current_threshold);
     subtitle_text = data->als_threshold_buffer;
   }
+#if PLATFORM_ASTERIX
+  else if (cell_index->row == DebuggingItemMotionSensitivity) {
+    subtitle_text = i18n_get(s_motion_sensitivity_labels[prv_motion_sensitivity_get_selection_index()], data);
+  }
+#endif
   menu_cell_basic_draw(ctx, cell_layer, title, subtitle_text, NULL);
 }
 
@@ -528,6 +585,11 @@ static void prv_debugging_select_callback(MenuLayer *menu_layer,
     case DebuggingItemALSThreshold:
       prv_als_threshold_menu_push(data);
       break;
+#if PLATFORM_ASTERIX
+    case DebuggingItemMotionSensitivity:
+      prv_motion_sensitivity_menu_push(data);
+      break;
+#endif
     default:
       WTF;
   }

src/fw/drivers/imu/lsm6dso/lsm6dso.c

@@ -92,6 +92,10 @@ static uint32_t s_tap_threshold = BOARD_CONFIG_ACCEL.accel_config.double_tap_thr
 static bool s_fifo_in_use = false;  // true when we have enabled FIFO batching
 static uint32_t s_last_vibe_detected = 0;
 
+// User-configured sensitivity percentage (0-100), where 100 = most sensitive
+// Default to 100% (maximum sensitivity) to maintain current behavior
+static uint8_t s_user_sensitivity_percent = 100;
+
 // Error tracking and recovery
 static uint32_t s_i2c_error_count = 0;
 static uint32_t s_last_successful_read_ms = 0;
@@ -657,16 +661,36 @@ static void prv_lsm6dso_configure_shake(bool enable, bool sensitivity_high) {
   // Duration: increase a bit to reduce spurious triggers
   lsm6dso_wkup_dur_set(&lsm6dso_ctx, sensitivity_high ? 0 : 1);
 
-  // Threshold: derive from board config; clamp into 0..63
+  // Threshold calculation:
+  // - Board config provides Low (15) and High (64) thresholds
+  // - sensitivity_high flag indicates stationary mode (use low threshold for any movement)
+  // - s_user_sensitivity_percent (0-100) controls normal mode threshold
+  //   * 100% = most sensitive = use Low threshold (15)
+  //   * 50% = medium = interpolate between Low and High (~40)
+  //   * 0% = least sensitive = use High threshold (64)
+  
   uint32_t raw_high = BOARD_CONFIG_ACCEL.accel_config.shake_thresholds[AccelThresholdHigh];
   uint32_t raw_low = BOARD_CONFIG_ACCEL.accel_config.shake_thresholds[AccelThresholdLow];
-  uint32_t raw = sensitivity_high ? raw_high : raw_low;
-  // Increase sensitivity: scale threshold down (halve). Ensure at least 2 to avoid noise storms.
-  raw = (raw + 1) / 2;     // divide by 2 rounding up
+  uint32_t raw;
+  
+  if (sensitivity_high) {
+    // Stationary mode: always use low threshold for maximum sensitivity
+    raw = raw_low;
+  } else {
+    // Normal mode: interpolate based on user preference
+    // Invert the percentage: 100% sensitive = low threshold, 0% sensitive = high threshold
+    uint32_t inverted_percent = 100 - s_user_sensitivity_percent;
+    raw = raw_low + ((raw_high - raw_low) * inverted_percent) / 100;
+  }
+  
+  // Clamp to valid range
   if (raw > 63) raw = 63;  // lsm6dso wk_ths is 6 bits
-  // Sanity fallback if 0 (avoid constant triggers) choose very low but non-zero
-  if (raw == 0) raw = 2;
+  if (raw < 2) raw = 2;     // Avoid noise storms with very low thresholds
+  
   lsm6dso_wkup_threshold_set(&lsm6dso_ctx, (uint8_t)raw);
+  
+  PBL_LOG(LOG_LEVEL_DEBUG, "LSM6DSO: Shake threshold set to %lu (sensitivity_high=%d, user_percent=%u)", 
+          raw, sensitivity_high, s_user_sensitivity_percent);
 }
 
 static void prv_lsm6dso_interrupt_handler(bool *should_context_switch) {
@@ -1361,3 +1385,18 @@ void lsm6dso_get_diagnostics(Lsm6dsoDiagnostics *diagnostics) {
 
   diagnostics->state_flags = flags;
 }
+
+void lsm6dso_set_sensitivity_percent(uint8_t percent) {
+  if (percent > 100) {
+    percent = 100; // Clamp to max
+  }
+  
+  s_user_sensitivity_percent = percent;
+  
+  // Reconfigure shake detection if it's currently enabled
+  if (s_lsm6dso_state.shake_detection_enabled) {
+    prv_lsm6dso_configure_shake(true, s_lsm6dso_state.shake_sensitivity_high);
+  }
+  
+  PBL_LOG(LOG_LEVEL_INFO, "LSM6DSO: User sensitivity set to %u percent", percent);
+}

src/fw/services/common/accel_manager.c

@@ -400,6 +400,39 @@ void analytics_external_collect_accel_samples_received(void) {
                 AnalyticsClient_System);
 }
 
+// Update the motion sensitivity based on user preference (0-100%)
+// This is called by the preferences system when the user changes the setting
+void accel_manager_update_sensitivity(uint8_t sensitivity_percent) {
+  // Sensitivity mapping:
+  // - sensitivity_percent: 0-100 where higher = more sensitive
+  // - For Asterix with LSM6DSO, this maps to the wake-up threshold
+  // - Lower threshold = more sensitive (triggers on smaller movements)
+  // - Higher threshold = less sensitive (requires larger movements to trigger)
+  //
+  // We'll map the user's percentage to a threshold multiplier:
+  // - 100% (most sensitive) = use Low threshold  (15) 
+  // - 50% (medium) = use mid-range (~40)
+  // - 0% (least sensitive) = use High threshold (64)
+  
+  #if PLATFORM_ASTERIX
+  extern void lsm6dso_set_sensitivity_percent(uint8_t percent);
+  mutex_lock_recursive(s_accel_manager_mutex);
+  lsm6dso_set_sensitivity_percent(sensitivity_percent);
+  mutex_unlock_recursive(s_accel_manager_mutex);
+  
+  PBL_LOG(LOG_LEVEL_INFO, "Motion sensitivity updated to %u percent", sensitivity_percent);
+  #else
+  // For other platforms, fall back to binary high/low setting
+  bool use_high_sensitivity = (sensitivity_percent >= 50);
+  mutex_lock_recursive(s_accel_manager_mutex);
+  accel_set_shake_sensitivity_high(use_high_sensitivity);
+  mutex_unlock_recursive(s_accel_manager_mutex);
+  
+  PBL_LOG(LOG_LEVEL_INFO, "Motion sensitivity updated to %u percent (using %s sensitivity)", 
+          sensitivity_percent, use_high_sensitivity ? "high" : "normal");
+  #endif
+}
+
 void accel_manager_init(void) {
   s_accel_manager_mutex = mutex_create_recursive();
 
@@ -417,6 +450,15 @@ void accel_manager_init(void) {
   prv_shake_add_subscriber_cb(PebbleTask_KernelMain);
 
   analytics_external_collect_accel_xyz_delta();
+  
+  // Apply saved motion sensitivity preference for Asterix/Obelix
+  // Only available in normal shell (not PRF)
+  #if (PLATFORM_ASTERIX) && !defined(RECOVERY_FW)
+  extern uint8_t shell_prefs_get_motion_sensitivity(void);
+  uint8_t saved_sensitivity = shell_prefs_get_motion_sensitivity();
+  accel_manager_update_sensitivity(saved_sensitivity);
+  PBL_LOG(LOG_LEVEL_INFO, "Initialized motion sensitivity to %u percent", saved_sensitivity);
+  #endif
 }
 
 static void prv_copy_accel_sample_to_accel_data(AccelDriverSample const *accel_sample,

src/fw/services/common/accel_manager.h

@@ -90,5 +90,10 @@ bool gyro_manager_run_selftest(void);
 // event from any small movements
 void accel_enable_high_sensitivity(bool high_sensitivity);
 
+// Update the motion sensitivity based on user preference (0-100%)
+// Only available on Asterix/Obelix platforms
+// 100 = most sensitive, 0 = least sensitive
+void accel_manager_update_sensitivity(uint8_t sensitivity_percent);
+
 // lightweight call to determine if the watch is idle
 bool accel_is_idle(void);

src/fw/shell/normal/prefs.c

@@ -75,6 +75,9 @@ static uint16_t s_backlight_intensity; // default pulled from BOARD_CONFIGs in s
 #define PREF_KEY_BACKLIGHT_MOTION "lightMotion"
 static bool s_backlight_motion_enabled = true;
 
+#define PREF_KEY_MOTION_SENSITIVITY "motionSensitivity"
+static uint8_t s_motion_sensitivity = 100; // Default to maximum sensitivity (100%)
+
 #define PREF_KEY_BACKLIGHT_AMBIENT_THRESHOLD "lightAmbientThreshold"
 static uint32_t s_backlight_ambient_threshold = 0; // default set from board config in shell_prefs_init()
 
@@ -275,6 +278,24 @@ static bool prv_set_s_backlight_motion_enabled(bool *enabled) {
   return true;
 }
 
+static bool prv_set_s_motion_sensitivity(uint8_t *sensitivity) {
+  // Clamp sensitivity to 0-100 range
+  if (*sensitivity > 100) {
+    s_motion_sensitivity = 100; // Reset to default if invalid
+    return false;
+  }
+  s_motion_sensitivity = *sensitivity;
+  
+  // Update accelerometer sensitivity in accel_manager
+  // This applies the setting to the hardware
+  #if PLATFORM_ASTERIX
+  extern void accel_manager_update_sensitivity(uint8_t sensitivity);
+  accel_manager_update_sensitivity(*sensitivity);
+  #endif
+  
+  return true;
+}
+
 static bool prv_set_s_backlight_ambient_threshold(uint32_t *threshold) {
   // Validate and constrain the threshold
   if (*threshold > AMBIENT_LIGHT_LEVEL_MAX) {
@@ -859,6 +880,18 @@ void backlight_set_motion_enabled(bool enable) {
   prv_pref_set(PREF_KEY_BACKLIGHT_MOTION, &enable, sizeof(enable));
 }
 
+uint8_t shell_prefs_get_motion_sensitivity(void) {
+  return s_motion_sensitivity;
+}
+
+void shell_prefs_set_motion_sensitivity(uint8_t sensitivity) {
+  // Clamp to valid range
+  if (sensitivity > 100) {
+    sensitivity = 50;
+  }
+  prv_pref_set(PREF_KEY_MOTION_SENSITIVITY, &sensitivity, sizeof(sensitivity));
+}
+
 uint32_t backlight_get_ambient_threshold(void) {
   return s_backlight_ambient_threshold;
 }

src/fw/shell/normal/prefs_values.h.inc

@@ -8,6 +8,7 @@
   PREFS_MACRO(PREF_KEY_BACKLIGHT_TIMEOUT_MS, s_backlight_timeout_ms)
   PREFS_MACRO(PREF_KEY_BACKLIGHT_INTENSITY, s_backlight_intensity)
   PREFS_MACRO(PREF_KEY_BACKLIGHT_MOTION, s_backlight_motion_enabled)
+  PREFS_MACRO(PREF_KEY_MOTION_SENSITIVITY, s_motion_sensitivity)
   PREFS_MACRO(PREF_KEY_BACKLIGHT_AMBIENT_THRESHOLD, s_backlight_ambient_threshold)
   PREFS_MACRO(PREF_KEY_STATIONARY, s_stationary_mode_enabled)
   PREFS_MACRO(PREF_KEY_DEFAULT_WORKER, s_default_worker)

src/fw/shell/prefs.h

@@ -89,6 +89,11 @@ void backlight_set_intensity_percent(uint8_t intensity_percent);
 bool backlight_is_motion_enabled(void);
 void backlight_set_motion_enabled(bool enable);
 
+// Motion sensitivity for accelerometer shake detection (0-100, lower = less sensitive)
+// Only available on platforms with LSM6DSO (Asterix, Obelix)
+uint8_t shell_prefs_get_motion_sensitivity(void);
+void shell_prefs_set_motion_sensitivity(uint8_t sensitivity);
+
 // The backlight ambient light threshold setting
 uint32_t backlight_get_ambient_threshold(void);
 void backlight_set_ambient_threshold(uint32_t threshold);