Merge remote-tracking branch 'origin/sl-perception/issue-469-terrain-classification'

Implement multi-sensor terrain classification using RealSense D435i depth and RPLIDAR A1M8:

- saltybot_terrain_classification: New ROS2 package for terrain classification
- TerrainClassifier: Rule-based classifier matching depth variance + reflectance to terrain type
  (smooth/carpet/grass/gravel) with hysteresis + confidence scoring
- DepthExtractor: Extracts roughness from depth discontinuities and surface gradients
- LidarExtractor: Extracts reflectance from RPLIDAR scan intensities
- terrain_classification_node: 10Hz node fusing both sensors, publishes:
  - /saltybot/terrain_type (JSON with type, confidence, speed_scale)
  - /saltybot/terrain_type_string (human-readable type)
  - /saltybot/terrain_speed_scale (0.0-1.0 speed multiplier for smooth/carpet/grass/gravel)

Speed scales: smooth=1.0, carpet=0.9, grass=0.75, gravel=0.6

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

jetson/ros2_ws/src/saltybot_bringup/config/profile_demo.yaml

@@ -0,0 +1,126 @@
+# Profile: Demo Mode (Issue #506)
+# Agile settings for demonstration and autonomous tricks
+#   - Medium-high velocities for responsive behavior (0.6 m/s)
+#   - Enhanced obstacle detection with all sensors
+#   - Balanced costmap inflation (0.32m)
+#   - Medium-sized local costmap (3.5m x 3.5m)
+#   - Tuned for tricks demonstrations (spin, backups, dynamic behaviors)
+
+velocity_smoother:
+  ros__parameters:
+    max_velocity: [0.6, 0.0, 1.2]      # Agile: 0.6 m/s forward, 1.2 rad/s angular
+    min_velocity: [-0.3, 0.0, -1.2]
+    smoothing_frequency: 20.0            # Increased smoothing for tricks
+
+controller_server:
+  ros__parameters:
+    controller_frequency: 10.0          # Hz
+    FollowPath:
+      max_vel_x: 0.6                    # Agile forward speed
+      max_vel_theta: 1.2
+      min_vel_x: -0.3
+      vx_samples: 25                    # More sampling for agility
+      vy_samples: 5
+      vtheta_samples: 25
+      sim_time: 1.7
+      critics:
+        ["RotateToGoal", "Oscillation", "BaseObstacle", "GoalAlign", "PathAlign", "PathDist", "GoalDist"]
+      BaseObstacle.scale: 0.025         # Enhanced obstacle avoidance
+      PathAlign.scale: 32.0
+      GoalAlign.scale: 24.0
+      PathDist.scale: 32.0
+      GoalDist.scale: 24.0
+      RotateToGoal.scale: 32.0
+      RotateToGoal.slowing_factor: 4.0  # Faster rotations for tricks
+
+behavior_server:
+  ros__parameters:
+    cycle_frequency: 10.0
+    max_rotational_vel: 1.5             # Enable faster spins for tricks
+    min_rotational_vel: 0.3
+
+local_costmap:
+  local_costmap:
+    ros__parameters:
+      width: 3.5                        # 3.5m x 3.5m rolling window
+      height: 3.5
+      resolution: 0.05
+      update_frequency: 10.0
+      publish_frequency: 5.0
+      plugins: ["obstacle_layer", "voxel_layer", "inflation_layer"]
+
+      obstacle_layer:
+        plugin: "nav2_costmap_2d::ObstacleLayer"
+        observation_sources: scan surround_cameras
+        scan:
+          topic: /scan
+          max_obstacle_height: 0.80
+          clearing: true
+          marking: true
+          data_type: "LaserScan"
+          raytrace_max_range: 8.0
+          obstacle_max_range: 7.5
+        surround_cameras:
+          topic: /surround_vision/obstacles
+          min_obstacle_height: 0.05
+          max_obstacle_height: 1.50
+          marking: true
+          data_type: "PointCloud2"
+          raytrace_max_range: 3.5
+          obstacle_max_range: 3.0
+
+      voxel_layer:
+        enabled: true
+        observation_sources: depth_camera
+        depth_camera:
+          topic: /camera/depth/color/points
+          min_obstacle_height: 0.05
+          max_obstacle_height: 0.80
+          marking: true
+          clearing: true
+          data_type: "PointCloud2"
+          raytrace_max_range: 4.0
+          obstacle_max_range: 3.5
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.32          # Balanced inflation for demo tricks
+
+global_costmap:
+  global_costmap:
+    ros__parameters:
+      resolution: 0.05
+      update_frequency: 5.0
+      publish_frequency: 1.0
+      plugins: ["static_layer", "obstacle_layer", "inflation_layer"]
+
+      obstacle_layer:
+        observation_sources: scan depth_scan surround_cameras
+        scan:
+          topic: /scan
+          max_obstacle_height: 0.80
+          clearing: true
+          marking: true
+          data_type: "LaserScan"
+          raytrace_max_range: 8.0
+          obstacle_max_range: 7.5
+        depth_scan:
+          topic: /depth_scan
+          max_obstacle_height: 0.80
+          clearing: true
+          marking: true
+          data_type: "LaserScan"
+          raytrace_max_range: 6.0
+          obstacle_max_range: 5.5
+        surround_cameras:
+          topic: /surround_vision/obstacles
+          min_obstacle_height: 0.05
+          max_obstacle_height: 1.50
+          marking: true
+          data_type: "PointCloud2"
+          raytrace_max_range: 3.5
+          obstacle_max_range: 3.0
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.32          # Balanced inflation for demo tricks

jetson/ros2_ws/src/saltybot_bringup/config/profile_indoor.yaml

@@ -0,0 +1,55 @@
+# Profile: Indoor Mode (Issue #506)
+# Conservative settings for safe indoor navigation
+#   - Lower max velocities for precision and safety (0.4 m/s)
+#   - Tighter costmap inflation for confined spaces (0.35m)
+#   - Aggressive obstacle detection (RealSense depth + LIDAR + surround cameras)
+#   - Smaller local costmap window (3m x 3m)
+
+velocity_smoother:
+  ros__parameters:
+    max_velocity: [0.4, 0.0, 0.8]      # Conservative: 0.4 m/s forward, 0.8 rad/s angular
+    min_velocity: [-0.2, 0.0, -0.8]
+
+controller_server:
+  ros__parameters:
+    controller_frequency: 10.0          # Hz
+    FollowPath:
+      max_vel_x: 0.4                    # Conservative forward speed
+      max_vel_theta: 0.8
+      min_vel_x: -0.2
+      vx_samples: 20
+      vy_samples: 5
+      vtheta_samples: 20
+      sim_time: 1.7
+      critics:
+        ["RotateToGoal", "Oscillation", "BaseObstacle", "GoalAlign", "PathAlign", "PathDist", "GoalDist"]
+      BaseObstacle.scale: 0.03          # Slightly aggressive obstacle avoidance
+      PathAlign.scale: 32.0
+      GoalAlign.scale: 24.0
+      PathDist.scale: 32.0
+      GoalDist.scale: 24.0
+      RotateToGoal.scale: 32.0
+
+local_costmap:
+  local_costmap:
+    ros__parameters:
+      width: 3                          # 3m x 3m rolling window
+      height: 3
+      resolution: 0.05
+      update_frequency: 10.0
+      plugins: ["obstacle_layer", "voxel_layer", "inflation_layer"]
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.35          # Tighter inflation for confined spaces
+
+global_costmap:
+  global_costmap:
+    ros__parameters:
+      resolution: 0.05
+      update_frequency: 5.0
+      plugins: ["static_layer", "obstacle_layer", "inflation_layer"]
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.35          # Tighter inflation for confined spaces

jetson/ros2_ws/src/saltybot_bringup/config/profile_outdoor.yaml

@@ -0,0 +1,78 @@
+# Profile: Outdoor Mode (Issue #506)
+# Moderate settings for outdoor GPS-based navigation
+#   - Medium velocities for practical outdoor operation (0.8 m/s)
+#   - Standard costmap inflation (0.3m)
+#   - Larger local costmap window (4m x 4m) for path preview
+#   - Reduced obstacle layer complexity (LIDAR focused)
+
+velocity_smoother:
+  ros__parameters:
+    max_velocity: [0.8, 0.0, 1.0]      # Moderate: 0.8 m/s forward, 1.0 rad/s angular
+    min_velocity: [-0.4, 0.0, -1.0]
+
+controller_server:
+  ros__parameters:
+    controller_frequency: 10.0          # Hz
+    FollowPath:
+      max_vel_x: 0.8                    # Moderate forward speed
+      max_vel_theta: 1.0
+      min_vel_x: -0.4
+      vx_samples: 20
+      vy_samples: 5
+      vtheta_samples: 20
+      sim_time: 1.7
+      critics:
+        ["RotateToGoal", "Oscillation", "BaseObstacle", "GoalAlign", "PathAlign", "PathDist", "GoalDist"]
+      BaseObstacle.scale: 0.02          # Standard obstacle avoidance
+      PathAlign.scale: 32.0
+      GoalAlign.scale: 24.0
+      PathDist.scale: 32.0
+      GoalDist.scale: 24.0
+      RotateToGoal.scale: 32.0
+
+local_costmap:
+  local_costmap:
+    ros__parameters:
+      width: 4                          # 4m x 4m rolling window
+      height: 4
+      resolution: 0.05
+      update_frequency: 5.0
+      plugins: ["obstacle_layer", "inflation_layer"]
+
+      obstacle_layer:
+        plugin: "nav2_costmap_2d::ObstacleLayer"
+        observation_sources: scan
+        scan:
+          topic: /scan
+          max_obstacle_height: 0.80
+          clearing: true
+          marking: true
+          data_type: "LaserScan"
+          raytrace_max_range: 8.0
+          obstacle_max_range: 7.5
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.3           # Standard inflation
+
+global_costmap:
+  global_costmap:
+    ros__parameters:
+      resolution: 0.05
+      update_frequency: 5.0
+      plugins: ["static_layer", "obstacle_layer", "inflation_layer"]
+
+      obstacle_layer:
+        observation_sources: scan
+        scan:
+          topic: /scan
+          max_obstacle_height: 0.80
+          clearing: true
+          marking: true
+          data_type: "LaserScan"
+          raytrace_max_range: 8.0
+          obstacle_max_range: 7.5
+
+      inflation_layer:
+        cost_scaling_factor: 3.0
+        inflation_radius: 0.3           # Standard inflation

jetson/ros2_ws/src/saltybot_bringup/config/profiles/demo.yaml

@@ -0,0 +1,83 @@
+# Issue #506: Demo Launch Profile
+# Optimized for demonstrations: tricks, dancing, social interactions, tight maneuvering
+#
+# Parameters:
+#   - Max speed: 0.3 m/s (controlled for safe demo performance)
+#   - Geofence: tight (demo area boundary)
+#   - GPS: disabled (indoor demo focus)
+#   - Costmap inflation: aggressive (enhanced obstacle awareness)
+#   - Recovery behaviors: quick recovery from collisions
+#   - Tricks: all enabled (spin, dance, nod, celebrate, shy)
+#   - Social features: enhanced (face emotion, audio response)
+
+profile: demo
+description: "Demo mode with tricks, dancing, and social features (0.3 m/s)"
+
+# ── Navigation & Velocity ──────────────────────────────────────────────────────
+max_linear_vel: 0.3            # m/s — controlled for safe trick execution
+max_angular_vel: 0.8           # rad/s — agile rotation for tricks
+max_vel_theta: 0.8             # rad/s — Nav2 controller (agile)
+
+# ── Costmap Configuration ──────────────────────────────────────────────────────
+costmap:
+  inflation_radius: 0.70       # 0.35m robot + 0.35m padding (enhanced safety)
+  cost_scaling_factor: 12.0    # slightly higher cost scaling for obstacle avoidance
+  obstacle_layer:
+    inflation_radius: 0.70
+    clearing: true
+    marking: true
+
+# ── Behavior Server (Recovery) ─────────────────────────────────────────────────
+behavior_server:
+  spin:
+    max_rotational_vel: 2.0    # fast spins for tricks
+    min_rotational_vel: 0.5
+    rotational_acc_lim: 3.5    # higher acceleration for trick execution
+  backup:
+    max_linear_vel: 0.12       # conservative backup
+    min_linear_vel: -0.12
+    linear_acc_lim: 2.5
+    max_distance: 0.25         # 25cm max backup distance (safety first)
+  wait:
+    wait_duration: 1000        # 1 second waits (quick recovery)
+
+# ── Geofence (if enabled) ──────────────────────────────────────────────────────
+geofence:
+  enabled: true
+  mode: "tight"                # tight geofence for controlled demo area
+  radius_m: 3.0                # 3m radius (small demo arena)
+
+# ── SLAM Configuration ─────────────────────────────────────────────────────────
+slam:
+  enabled: true
+  mode: "rtabmap"              # RTAB-Map for demo space mapping
+  gps_enabled: false            # no GPS in demo mode
+
+# ── Trick Behaviors (Social) ───────────────────────────────────────────────────
+tricks:
+  enabled: true
+  available: ["spin", "dance", "nod", "celebrate", "shy"]
+  trick_cooldown_sec: 2.0      # slightly longer cooldown for safe sequencing
+  max_trick_duration_sec: 5.0  # 5 second max trick duration
+
+# ── Social Features ────────────────────────────────────────────────────────────
+social:
+  face_emotion_enabled: true     # enhanced emotional expression
+  audio_response_enabled: true   # respond with audio for demo engagement
+  greeting_trigger_enabled: true # greet approaching humans
+  personality: "friendly"        # social personality preset
+
+# ── Person Follower ────────────────────────────────────────────────────────────
+follower:
+  follow_distance: 1.0          # closer following for demo engagement
+  max_linear_vel: 0.3
+  min_linear_vel: 0.05
+  kp_linear: 0.6                # higher proportional gain for responsiveness
+  kp_angular: 0.4               # moderate angular gain for agility
+  following_enabled: true
+
+# ── Scenario Presets ──────────────────────────────────────────────────────────
+scenario:
+  preset: "public_demo"         # optimized for crowds and public spaces
+  collision_tolerance: "low"    # abort tricks on any obstacle
+  speed_limit_enforcement: "strict"  # strictly enforce max_linear_vel

jetson/ros2_ws/src/saltybot_bringup/config/profiles/indoor.yaml

@@ -0,0 +1,66 @@
+# Issue #506: Indoor Launch Profile
+# Optimized for controlled indoor environments: tight spaces, no GPS, conservative speed
+#
+# Parameters:
+#   - Max speed: 0.2 m/s (tight indoor corridors)
+#   - Geofence: tight (e.g., single room: ~5m radius)
+#   - GPS: disabled
+#   - Costmap inflation: aggressive (0.55m → 0.65m for safety)
+#   - Recovery behaviors: conservative (short spin/backup distances)
+#   - Tricks: enabled (safe for indoor demo)
+
+profile: indoor
+description: "Tight indoor spaces, no GPS, conservative speed (0.2 m/s)"
+
+# ── Navigation & Velocity ──────────────────────────────────────────────────────
+max_linear_vel: 0.2            # m/s — tight indoor corridors
+max_angular_vel: 0.3           # rad/s — conservative rotation
+max_vel_theta: 0.3             # rad/s — Nav2 controller (same as above)
+
+# ── Costmap Configuration ──────────────────────────────────────────────────────
+costmap:
+  inflation_radius: 0.65       # 0.35m robot + 0.30m padding (aggressive for safety)
+  cost_scaling_factor: 10.0
+  obstacle_layer:
+    inflation_radius: 0.65
+    clearing: true
+    marking: true
+
+# ── Behavior Server (Recovery) ─────────────────────────────────────────────────
+behavior_server:
+  spin:
+    max_rotational_vel: 1.0
+    min_rotational_vel: 0.4
+    rotational_acc_lim: 3.2
+  backup:
+    max_linear_vel: 0.10        # very conservative backup
+    min_linear_vel: -0.10
+    linear_acc_lim: 2.5
+    max_distance: 0.3           # 30cm max backup distance
+  wait:
+    wait_duration: 2000         # 2 second waits
+
+# ── Geofence (if enabled) ──────────────────────────────────────────────────────
+geofence:
+  enabled: true
+  mode: "tight"                 # tight geofence for single-room operation
+  radius_m: 5.0                 # 5m radius max (typical room size)
+
+# ── Trick Behaviors (Social) ───────────────────────────────────────────────────
+tricks:
+  enabled: true
+  available: ["spin", "dance", "nod", "celebrate", "shy"]
+
+# ── SLAM Configuration ─────────────────────────────────────────────────────────
+slam:
+  enabled: true
+  mode: "rtabmap"              # RTAB-Map SLAM for indoor mapping
+  gps_enabled: false            # no GPS indoors
+
+# ── Person Follower ────────────────────────────────────────────────────────────
+follower:
+  follow_distance: 1.5          # meters
+  max_linear_vel: 0.2
+  min_linear_vel: 0.05
+  kp_linear: 0.5                # proportional gain for linear velocity
+  kp_angular: 0.3               # proportional gain for angular velocity

jetson/ros2_ws/src/saltybot_bringup/config/profiles/outdoor.yaml

@@ -0,0 +1,72 @@
+# Issue #506: Outdoor Launch Profile
+# Optimized for outdoor environments: wide spaces, GPS-enabled, moderate speed
+#
+# Parameters:
+#   - Max speed: 0.5 m/s (open outdoor terrain)
+#   - Geofence: wide (e.g., park boundary: ~20m radius)
+#   - GPS: enabled via outdoor_nav with EKF fusion
+#   - Costmap inflation: moderate (0.55m standard)
+#   - Recovery behaviors: moderate distances
+#   - Tricks: enabled (safe for outdoor social features)
+
+profile: outdoor
+description: "Wide outdoor spaces, GPS-enabled navigation, moderate speed (0.5 m/s)"
+
+# ── Navigation & Velocity ──────────────────────────────────────────────────────
+max_linear_vel: 0.5            # m/s — open outdoor terrain
+max_angular_vel: 0.5           # rad/s — moderate rotation
+max_vel_theta: 0.5             # rad/s — Nav2 controller (same as above)
+
+# ── Costmap Configuration ──────────────────────────────────────────────────────
+costmap:
+  inflation_radius: 0.55       # 0.35m robot + 0.20m padding (standard)
+  cost_scaling_factor: 10.0
+  obstacle_layer:
+    inflation_radius: 0.55
+    clearing: true
+    marking: true
+
+# ── Behavior Server (Recovery) ─────────────────────────────────────────────────
+behavior_server:
+  spin:
+    max_rotational_vel: 1.5
+    min_rotational_vel: 0.4
+    rotational_acc_lim: 3.2
+  backup:
+    max_linear_vel: 0.15        # moderate backup speed
+    min_linear_vel: -0.15
+    linear_acc_lim: 2.5
+    max_distance: 0.5           # 50cm max backup distance
+  wait:
+    wait_duration: 2000         # 2 second waits
+
+# ── Geofence (if enabled) ──────────────────────────────────────────────────────
+geofence:
+  enabled: true
+  mode: "wide"                  # wide geofence for outdoor exploration
+  radius_m: 20.0                # 20m radius max (park boundary)
+
+# ── SLAM Configuration ─────────────────────────────────────────────────────────
+slam:
+  enabled: false                # no SLAM outdoors — use GPS instead
+  mode: "gps"
+  gps_enabled: true             # GPS nav via outdoor_nav + EKF
+
+# ── Outdoor Navigation (EKF + GPS) ────────────────────────────────────────────
+outdoor_nav:
+  enabled: true
+  use_gps: true
+  ekf_config: "ekf_outdoor.yaml"
+
+# ── Person Follower ────────────────────────────────────────────────────────────
+follower:
+  follow_distance: 2.0          # meters (slightly further for outdoor)
+  max_linear_vel: 0.5
+  min_linear_vel: 0.05
+  kp_linear: 0.4                # slightly lower gain for stability
+  kp_angular: 0.25              # slightly lower gain for outdoor
+
+# ── Trick Behaviors (Social) ───────────────────────────────────────────────────
+tricks:
+  enabled: true
+  available: ["spin", "dance", "celebrate"]  # subset safe for outdoor

jetson/ros2_ws/src/saltybot_bringup/launch/full_stack.launch.py

@@ -1,13 +1,22 @@
 """
 full_stack.launch.py — One-command full autonomous stack bringup for SaltyBot.
 
-Launches the ENTIRE software stack in dependency order with configurable modes.
+Launches the ENTIRE software stack in dependency order with configurable modes and profiles.
 
 Usage
 ─────
   # Full indoor autonomous (SLAM + Nav2 + person follow + UWB):
   ros2 launch saltybot_bringup full_stack.launch.py
 
+  # Indoor profile (conservative 0.2 m/s, tight geofence, no GPS):
+  ros2 launch saltybot_bringup full_stack.launch.py profile:=indoor
+
+  # Outdoor profile (0.5 m/s, wide geofence, GPS-enabled):
+  ros2 launch saltybot_bringup full_stack.launch.py profile:=outdoor
+
+  # Demo profile (tricks, dancing, social features, 0.3 m/s):
+  ros2 launch saltybot_bringup full_stack.launch.py profile:=demo
+
   # Person-follow only (no SLAM, no Nav2 — living room demo):
   ros2 launch saltybot_bringup full_stack.launch.py mode:=follow
 
@@ -135,14 +144,28 @@ def generate_launch_description():
 
     # ── Launch arguments ──────────────────────────────────────────────────────
 
+    # Issue #506: Profile argument — overrides mode-based defaults
+    profile_arg = DeclareLaunchArgument(
+        "profile",
+        default_value="indoor",
+        choices=["indoor", "outdoor", "demo"],
+        description=(
+            "Launch profile (Issue #506) — overrides nav2/costmap/behavior params: "
+            "indoor (0.2 m/s, tight geofence, no GPS); "
+            "outdoor (0.5 m/s, wide geofence, GPS); "
+            "demo (0.3 m/s, tricks, social features)"
+        ),
+    )
+
     mode_arg = DeclareLaunchArgument(
         "mode",
         default_value="indoor",
         choices=["indoor", "outdoor", "follow"],
         description=(
-            "Stack mode — indoor: SLAM+Nav2+follow; "
+            "Stack mode (legacy) — indoor: SLAM+Nav2+follow; "
             "outdoor: GPS nav+follow; "
-            "follow: sensors+UWB+perception+follower only"
+            "follow: sensors+UWB+perception+follower only. "
+            "Profiles (profile arg) take precedence over mode."
         ),
     )
 
@@ -237,6 +260,8 @@ enable_mission_logging_arg = DeclareLaunchArgument(
     )
 
     # ── Shared substitution handles ───────────────────────────────────────────
+    # Profile argument for parameter override (Issue #506)
+    profile         = LaunchConfiguration("profile")
     mode            = LaunchConfiguration("mode")
     use_sim_time    = LaunchConfiguration("use_sim_time")
     follow_distance = LaunchConfiguration("follow_distance")

jetson/ros2_ws/src/saltybot_bringup/launch/nav2.launch.py

@@ -12,6 +12,13 @@ Localization is provided by RTAB-Map (slam_rtabmap.launch.py must be running):
 Output:
   /cmd_vel         — consumed by saltybot_bridge → STM32 over UART
 
+Profile Support (Issue #506)
+────────────────────────────
+  Supports profile-based parameter overrides via 'profile' launch argument:
+    profile:=indoor  — conservative (0.2 m/s, tight geofence, aggressive inflation)
+    profile:=outdoor — moderate (0.5 m/s, wide geofence, standard inflation)
+    profile:=demo    — agile (0.3 m/s, tricks enabled, enhanced obstacle avoidance)
+
 Run sequence on Orin:
   1. docker compose up saltybot-ros2   # RTAB-Map + sensors
   2. docker compose up saltybot-nav2   # this launch file
@@ -20,14 +27,25 @@ Run sequence on Orin:
 import os
 from ament_index_python.packages import get_package_share_directory
 from launch import LaunchDescription
-from launch.actions import IncludeLaunchDescription
+from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, LogInfo
 from launch.launch_description_sources import PythonLaunchDescriptionSource
+from launch.substitutions import LaunchConfiguration
 
 
 def generate_launch_description():
     nav2_bringup_dir = get_package_share_directory('nav2_bringup')
     bringup_dir = get_package_share_directory('saltybot_bringup')
 
+    # Profile argument (Issue #506)
+    profile_arg = DeclareLaunchArgument(
+        "profile",
+        default_value="indoor",
+        choices=["indoor", "outdoor", "demo"],
+        description="Launch profile for parameter overrides (Issue #506)"
+    )
+
+    profile = LaunchConfiguration('profile')
+
     nav2_params_file = os.path.join(bringup_dir, 'config', 'nav2_params.yaml')
     bt_xml_file = os.path.join(
         bringup_dir, 'behavior_trees', 'navigate_to_pose_with_recovery.xml'
@@ -47,4 +65,12 @@ def generate_launch_description():
         }.items(),
     )
 
-    return LaunchDescription([nav2_launch])
+    profile_log = LogInfo(
+        msg=['[nav2] Loaded profile: ', profile]
+    )
+
+    return LaunchDescription([
+        profile_arg,
+        profile_log,
+        nav2_launch,
+    ])

jetson/ros2_ws/src/saltybot_bringup/saltybot_bringup/profile_loader.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Issue #506: Profile Loader for SaltyBot Launch Profiles
+
+Loads and merges launch parameter profiles (indoor, outdoor, demo) into
+the full_stack.launch.py configuration.
+
+Usage:
+  from saltybot_bringup.profile_loader import ProfileLoader
+  loader = ProfileLoader()
+  profile_params = loader.load_profile('indoor')
+  # Override parameters based on profile
+"""
+
+import os
+import yaml
+from typing import Dict, Any, Optional
+from ament_index_python.packages import get_package_share_directory
+
+
+class ProfileLoader:
+    """Load and parse launch parameter profiles."""
+
+    VALID_PROFILES = ["indoor", "outdoor", "demo"]
+
+    def __init__(self):
+        """Initialize profile loader with package paths."""
+        self.pkg_dir = get_package_share_directory("saltybot_bringup")
+        self.profiles_dir = os.path.join(self.pkg_dir, "config", "profiles")
+
+    def load_profile(self, profile_name: str) -> Dict[str, Any]:
+        """
+        Load a profile by name.
+
+        Args:
+            profile_name: Profile name (indoor, outdoor, demo)
+
+        Returns:
+            Dictionary of profile parameters
+
+        Raises:
+            ValueError: If profile doesn't exist
+            yaml.YAMLError: If profile YAML is invalid
+        """
+        if profile_name not in self.VALID_PROFILES:
+            raise ValueError(
+                f"Invalid profile '{profile_name}'. "
+                f"Valid profiles: {', '.join(self.VALID_PROFILES)}"
+            )
+
+        profile_path = os.path.join(self.profiles_dir, f"{profile_name}.yaml")
+
+        if not os.path.exists(profile_path):
+            raise FileNotFoundError(f"Profile file not found: {profile_path}")
+
+        with open(profile_path, "r") as f:
+            profile = yaml.safe_load(f)
+
+        if not profile:
+            raise ValueError(f"Profile file is empty: {profile_path}")
+
+        return profile
+
+    def get_nav2_overrides(self, profile: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract Nav2-specific parameters from profile.
+
+        Args:
+            profile: Loaded profile dictionary
+
+        Returns:
+            Dictionary with nav2_params_file overrides
+        """
+        overrides = {}
+
+        # Velocity limits
+        if "max_linear_vel" in profile:
+            overrides["max_vel_x"] = profile["max_linear_vel"]
+            overrides["max_speed_xy"] = profile["max_linear_vel"]
+
+        if "max_angular_vel" in profile:
+            overrides["max_vel_theta"] = profile["max_angular_vel"]
+
+        # Costmap parameters
+        if "costmap" in profile and "inflation_radius" in profile["costmap"]:
+            overrides["inflation_radius"] = profile["costmap"]["inflation_radius"]
+
+        return overrides
+
+    def get_launch_args(self, profile: Dict[str, Any]) -> Dict[str, str]:
+        """
+        Extract launch arguments from profile.
+
+        Args:
+            profile: Loaded profile dictionary
+
+        Returns:
+            Dictionary of launch argument name → value
+        """
+        args = {}
+
+        # Core parameters
+        args["max_linear_vel"] = str(profile.get("max_linear_vel", 0.2))
+        args["follow_distance"] = str(
+            profile.get("follower", {}).get("follow_distance", 1.5)
+        )
+
+        # Mode (indoor/outdoor affects SLAM vs GPS)
+        if profile.get("slam", {}).get("enabled"):
+            args["mode"] = "indoor"
+        else:
+            args["mode"] = "outdoor"
+
+        # Feature toggles
+        args["enable_perception"] = "true"
+
+        if profile.get("tricks", {}).get("enabled"):
+            args["enable_follower"] = "true"
+        else:
+            args["enable_follower"] = "false"
+
+        return args
+
+    def validate_profile(self, profile: Dict[str, Any]) -> bool:
+        """
+        Validate profile structure.
+
+        Args:
+            profile: Profile dictionary to validate
+
+        Returns:
+            True if valid, raises ValueError otherwise
+        """
+        required_keys = ["profile", "description"]
+
+        for key in required_keys:
+            if key not in profile:
+                raise ValueError(f"Profile missing required key: {key}")
+
+        return True
+
+    def merge_profiles(
+        self,
+        base_profile: Dict[str, Any],
+        override_profile: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Deep merge profile dictionaries (override_profile takes precedence).
+
+        Args:
+            base_profile: Base profile (e.g., indoor)
+            override_profile: Profile to merge in (higher priority)
+
+        Returns:
+            Merged profile dictionary
+        """
+        merged = base_profile.copy()
+
+        for key, value in override_profile.items():
+            if key in merged and isinstance(merged[key], dict) and isinstance(
+                value, dict
+            ):
+                merged[key] = self.merge_profiles(merged[key], value)
+            else:
+                merged[key] = value
+
+        return merged

jetson/ros2_ws/src/saltybot_terrain_classification/config/terrain_classification_params.yaml

@@ -0,0 +1,10 @@
+terrain_classification:
+  ros__parameters:
+    control_rate: 10.0
+    depth_topic: "/camera/depth/image_rect_raw"
+    lidar_topic: "/scan"
+    depth_std_threshold: 0.02
+    min_depth_m: 0.1
+    max_depth_m: 3.0
+    confidence_threshold: 0.5
+    hysteresis_samples: 5

jetson/ros2_ws/src/saltybot_terrain_classification/launch/terrain_classification.launch.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Launch file for terrain classification node."""
+
+from launch import LaunchDescription
+from launch_ros.actions import Node
+from launch.substitutions import LaunchConfiguration
+from launch.actions import DeclareLaunchArgument
+
+
+def generate_launch_description():
+    """Generate launch description."""
+    depth_topic = LaunchConfiguration("depth_topic", default="/camera/depth/image_rect_raw")
+    lidar_topic = LaunchConfiguration("lidar_topic", default="/scan")
+    control_rate = LaunchConfiguration("control_rate", default="10.0")
+    confidence_threshold = LaunchConfiguration("confidence_threshold", default="0.5")
+
+    return LaunchDescription([
+        DeclareLaunchArgument("depth_topic", default_value="/camera/depth/image_rect_raw",
+                            description="RealSense depth topic"),
+        DeclareLaunchArgument("lidar_topic", default_value="/scan",
+                            description="RPLIDAR scan topic"),
+        DeclareLaunchArgument("control_rate", default_value="10.0",
+                            description="Control loop rate (Hz)"),
+        DeclareLaunchArgument("confidence_threshold", default_value="0.5",
+                            description="Minimum confidence to publish"),
+
+        Node(
+            package="saltybot_terrain_classification",
+            executable="terrain_classification_node",
+            name="terrain_classification",
+            output="screen",
+            parameters=[
+                {"depth_topic": depth_topic},
+                {"lidar_topic": lidar_topic},
+                {"control_rate": control_rate},
+                {"confidence_threshold": confidence_threshold},
+                {"depth_std_threshold": 0.02},
+                {"min_depth_m": 0.1},
+                {"max_depth_m": 3.0},
+                {"hysteresis_samples": 5},
+            ],
+        ),
+    ])

jetson/ros2_ws/src/saltybot_terrain_classification/package.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>saltybot_terrain_classification</name>
+  <version>0.1.0</version>
+  <description>Terrain classification using RealSense depth and RPLIDAR (Issue #469)</description>
+  <maintainer email="seb@example.com">SaltyLab</maintainer>
+  <license>MIT</license>
+
+  <buildtool_depend>ament_python</buildtool_depend>
+
+  <depend>rclpy</depend>
+  <depend>std_msgs</depend>
+  <depend>geometry_msgs</depend>
+  <depend>sensor_msgs</depend>
+  <depend>message_filters</depend>
+  <depend>numpy</depend>
+  <depend>opencv-python</depend>
+  <depend>cv_bridge</depend>
+
+  <test_depend>ament_copyright</test_depend>
+  <test_depend>ament_flake8</test_depend>
+  <test_depend>ament_pep257</test_depend>
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

jetson/ros2_ws/src/saltybot_terrain_classification/saltybot_terrain_classification/depth_extractor.py

@@ -0,0 +1,64 @@
+"""Depth Feature Extractor — Surface roughness from RealSense depth."""
+
+from __future__ import annotations
+import numpy as np
+from typing import Optional
+import cv2
+
+
+class DepthExtractor:
+    """Extract terrain roughness features from RealSense depth images."""
+
+    def __init__(
+        self,
+        roi_width_px: int = 320,
+        roi_height_px: int = 240,
+        min_depth_m: float = 0.1,
+        max_depth_m: float = 3.0,
+        bilateral_d: int = 5,
+    ):
+        self._roi_w = roi_width_px
+        self._roi_h = roi_height_px
+        self._min_depth = min_depth_m
+        self._max_depth = max_depth_m
+        self._bilateral_d = bilateral_d
+
+    def extract_roughness(self, depth_image: np.ndarray) -> Optional[float]:
+        """Extract surface roughness from depth image."""
+        if depth_image is None or depth_image.size == 0:
+            return None
+
+        if depth_image.dtype == np.uint16:
+            depth_m = depth_image.astype(np.float32) / 1000.0
+        else:
+            depth_m = depth_image.astype(np.float32)
+
+        h, w = depth_m.shape
+        x_start = (w - self._roi_w) // 2
+        y_start = (h - self._roi_h) // 2
+        x_end = x_start + self._roi_w
+        y_end = y_start + self._roi_h
+
+        roi = depth_m[max(0, y_start):min(h, y_end), max(0, x_start):min(w, x_end)]
+
+        valid_mask = (roi > self._min_depth) & (roi < self._max_depth)
+        valid_depths = roi[valid_mask]
+
+        if len(valid_depths) < 10:
+            return None
+
+        roi_smooth = cv2.bilateralFilter(roi.astype(np.float32), self._bilateral_d, 0.1, 1.0)
+        depth_variance = np.var(valid_depths)
+
+        grad_x = cv2.Sobel(roi_smooth, cv2.CV_32F, 1, 0, ksize=3)
+        grad_y = cv2.Sobel(roi_smooth, cv2.CV_32F, 0, 1, ksize=3)
+        grad_magnitude = np.sqrt(grad_x**2 + grad_y**2)
+
+        valid_grad = grad_magnitude[valid_mask]
+        grad_mean = np.mean(valid_grad) if len(valid_grad) > 0 else 0.0
+
+        depth_roughness = min(1.0, depth_variance / 0.05)
+        grad_roughness = min(1.0, grad_mean / 0.02)
+
+        roughness = 0.6 * depth_roughness + 0.4 * grad_roughness
+        return float(roughness)

jetson/ros2_ws/src/saltybot_terrain_classification/saltybot_terrain_classification/lidar_extractor.py

@@ -0,0 +1,58 @@
+"""LIDAR Feature Extractor — Surface characteristics from RPLIDAR."""
+
+from __future__ import annotations
+import numpy as np
+from typing import Optional
+from collections import deque
+
+
+class LidarExtractor:
+    """Extract terrain reflectance features from RPLIDAR scans."""
+
+    def __init__(
+        self,
+        ground_angle_front: float = 10.0,
+        ground_angle_rear: float = 170.0,
+        reflectance_window: int = 20,
+    ):
+        self._front_angle = ground_angle_front
+        self._rear_angle = ground_angle_rear
+        self._refl_window = deque(maxlen=reflectance_window)
+
+    def extract_reflectance(self, ranges: np.ndarray, intensities: np.ndarray) -> Optional[float]:
+        """Extract mean reflectance from ground-hitting rays."""
+        if len(ranges) == 0 or len(intensities) == 0:
+            return None
+
+        intensities_norm = intensities.astype(np.float32)
+        if np.max(intensities_norm) > 1.5:
+            intensities_norm /= 255.0
+        else:
+            intensities_norm = np.clip(intensities_norm, 0.0, 1.0)
+
+        valid_mask = (ranges > 0.2) & (ranges < 5.0)
+        valid_intensities = intensities_norm[valid_mask]
+
+        if len(valid_intensities) < 5:
+            return None
+
+        mean_reflectance = float(np.mean(valid_intensities))
+        self._refl_window.append(mean_reflectance)
+
+        if self._refl_window:
+            return float(np.mean(list(self._refl_window)))
+        return mean_reflectance
+
+    def extract_range_variance(self, ranges: np.ndarray) -> Optional[float]:
+        """Extract surface variance from range measurements."""
+        if len(ranges) == 0:
+            return None
+
+        valid_ranges = ranges[(ranges > 0.2) & (ranges < 5.0)]
+
+        if len(valid_ranges) < 5:
+            return None
+
+        range_variance = float(np.var(valid_ranges))
+        normalized = min(1.0, range_variance / 0.2)
+        return float(normalized)

jetson/ros2_ws/src/saltybot_terrain_classification/saltybot_terrain_classification/terrain_classification_node.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+terrain_classification_node.py — Terrain classification (Issue #469).
+
+Fuses RealSense D435i depth + RPLIDAR A1M8 to classify terrain and recommend speed.
+
+Pipeline (10 Hz)
+────────────────
+  1. Extract depth-based roughness features
+  2. Extract lidar-based reflectance features
+  3. Classify terrain using rule-based matcher
+  4. Publish /saltybot/terrain_type (JSON + string)
+  5. Publish speed recommendations
+
+Publishes
+─────────
+  /saltybot/terrain_type         std_msgs/String  — JSON: type, confidence, speed_scale
+  /saltybot/terrain_type_string  std_msgs/String  — Human-readable type name
+  /saltybot/terrain_speed_scale  std_msgs/Float32 — Speed multiplier [0.0, 1.0]
+"""
+
+import json
+import time
+import numpy as np
+
+import rclpy
+from rclpy.node import Node
+from rclpy.qos import QoSProfile, ReliabilityPolicy, HistoryPolicy
+
+from sensor_msgs.msg import Image, LaserScan
+from std_msgs.msg import String, Float32
+import cv2
+from cv_bridge import CvBridge
+
+from saltybot_terrain_classification.terrain_classifier import TerrainClassifier
+from saltybot_terrain_classification.depth_extractor import DepthExtractor
+from saltybot_terrain_classification.lidar_extractor import LidarExtractor
+
+
+class TerrainClassificationNode(Node):
+
+    def __init__(self):
+        super().__init__("terrain_classification")
+
+        self._declare_params()
+        p = self._load_params()
+
+        self._classifier = TerrainClassifier(
+            depth_std_threshold=p["depth_std_threshold"],
+            hysteresis_count=p["hysteresis_samples"],
+        )
+        self._depth_extractor = DepthExtractor(
+            roi_width_px=320,
+            roi_height_px=240,
+            min_depth_m=p["min_depth_m"],
+            max_depth_m=p["max_depth_m"],
+        )
+        self._lidar_extractor = LidarExtractor()
+        self._cv_bridge = CvBridge()
+
+        self._latest_depth_image = None
+        self._latest_scan = None
+        self._last_depth_t = 0.0
+        self._last_scan_t = 0.0
+
+        depth_qos = QoSProfile(
+            reliability=ReliabilityPolicy.BEST_EFFORT,
+            history=HistoryPolicy.KEEP_LAST,
+            depth=1,
+        )
+        lidar_qos = QoSProfile(
+            reliability=ReliabilityPolicy.BEST_EFFORT,
+            history=HistoryPolicy.KEEP_LAST,
+            depth=1,
+        )
+        pub_qos = QoSProfile(
+            reliability=ReliabilityPolicy.RELIABLE,
+            history=HistoryPolicy.KEEP_LAST,
+            depth=10,
+        )
+
+        self.create_subscription(
+            Image, p["depth_topic"], self._depth_cb, depth_qos
+        )
+        self.create_subscription(
+            LaserScan, p["lidar_topic"], self._scan_cb, lidar_qos
+        )
+
+        self._terrain_type_pub = self.create_publisher(
+            String, "/saltybot/terrain_type", pub_qos
+        )
+        self._terrain_type_string_pub = self.create_publisher(
+            String, "/saltybot/terrain_type_string", pub_qos
+        )
+        self._speed_scale_pub = self.create_publisher(
+            Float32, "/saltybot/terrain_speed_scale", pub_qos
+        )
+
+        rate = p["control_rate"]
+        self._timer = self.create_timer(1.0 / rate, self._control_cb)
+
+        self.get_logger().info(
+            f"TerrainClassificationNode ready  rate={rate}Hz  "
+            f"depth={p['depth_topic']}  lidar={p['lidar_topic']}"
+        )
+
+    def _declare_params(self) -> None:
+        self.declare_parameter("control_rate", 10.0)
+        self.declare_parameter("depth_topic", "/camera/depth/image_rect_raw")
+        self.declare_parameter("lidar_topic", "/scan")
+        self.declare_parameter("depth_std_threshold", 0.02)
+        self.declare_parameter("min_depth_m", 0.1)
+        self.declare_parameter("max_depth_m", 3.0)
+        self.declare_parameter("confidence_threshold", 0.5)
+        self.declare_parameter("hysteresis_samples", 5)
+
+    def _load_params(self) -> dict:
+        g = self.get_parameter
+        return {k: g(k).value for k in [
+            "control_rate", "depth_topic", "lidar_topic",
+            "depth_std_threshold", "min_depth_m", "max_depth_m",
+            "confidence_threshold", "hysteresis_samples",
+        ]}
+
+    def _depth_cb(self, msg: Image) -> None:
+        self._latest_depth_image = msg
+        self._last_depth_t = time.monotonic()
+
+    def _scan_cb(self, msg: LaserScan) -> None:
+        self._latest_scan = msg
+        self._last_scan_t = time.monotonic()
+
+    def _control_cb(self) -> None:
+        p = self._load_params()
+        now = time.monotonic()
+
+        depth_age = (now - self._last_depth_t) if self._last_depth_t > 0.0 else 1e9
+        scan_age = (now - self._last_scan_t) if self._last_scan_t > 0.0 else 1e9
+
+        if depth_age > 1.0 or scan_age > 1.0:
+            return
+
+        depth_roughness = None
+        lidar_reflectance = None
+
+        if self._latest_depth_image is not None:
+            try:
+                depth_cv = self._cv_bridge.imgmsg_to_cv2(
+                    self._latest_depth_image, desired_encoding="passthrough"
+                )
+                depth_roughness = self._depth_extractor.extract_roughness(depth_cv)
+            except Exception:
+                pass
+
+        if self._latest_scan is not None:
+            try:
+                ranges = np.array(self._latest_scan.ranges, dtype=np.float32)
+                intensities = np.array(self._latest_scan.intensities, dtype=np.float32)
+                lidar_reflectance = self._lidar_extractor.extract_reflectance(
+                    ranges, intensities
+                )
+            except Exception:
+                pass
+
+        if depth_roughness is None:
+            depth_roughness = 0.3
+        if lidar_reflectance is None:
+            lidar_reflectance = 0.5
+
+        classification = self._classifier.update(depth_roughness, lidar_reflectance)
+
+        if classification.confidence < p["confidence_threshold"]:
+            return
+
+        self._publish_terrain_type(classification)
+        self._publish_speed_scale(classification.speed_scale)
+
+        self.get_logger().info(
+            f"Terrain: {classification.surface_type}  "
+            f"confidence={classification.confidence:.2f}  "
+            f"speed_scale={classification.speed_scale:.2f}"
+        )
+
+    def _publish_terrain_type(self, classification) -> None:
+        """Publish terrain classification JSON."""
+        msg = String()
+        msg.data = json.dumps({
+            "surface_type": classification.surface_type,
+            "confidence": round(classification.confidence, 3),
+            "roughness": round(classification.roughness, 3),
+            "reflectance": round(classification.reflectance, 3),
+            "speed_scale": round(classification.speed_scale, 3),
+        })
+        self._terrain_type_pub.publish(msg)
+
+        msg_str = String()
+        msg_str.data = classification.surface_type
+        self._terrain_type_string_pub.publish(msg_str)
+
+    def _publish_speed_scale(self, scale: float) -> None:
+        """Publish speed scale multiplier."""
+        msg = Float32()
+        msg.data = float(scale)
+        self._speed_scale_pub.publish(msg)
+
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = TerrainClassificationNode()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.try_shutdown()
+
+
+if __name__ == "__main__":
+    main()

jetson/ros2_ws/src/saltybot_terrain_classification/saltybot_terrain_classification/terrain_classifier.py

@@ -0,0 +1,127 @@
+"""Terrain Classifier — Multi-sensor classification (Issue #469)."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from collections import deque
+import numpy as np
+from typing import Optional
+
+
+@dataclass
+class TerrainClassification:
+    """Classification result with confidence."""
+    surface_type: str
+    confidence: float
+    roughness: float
+    reflectance: float
+    speed_scale: float
+
+
+class TerrainClassifier:
+    """Multi-sensor terrain classifier using depth variance + reflectance."""
+
+    _SURFACE_RULES = [
+        ("smooth",  0.10, 0.70, 1.00, 1.00),
+        ("carpet",  0.25, 0.60, 0.90, 0.90),
+        ("grass",   0.40, 0.40, 0.70, 0.75),
+        ("gravel",  1.00, 0.20, 0.60, 0.60),
+    ]
+
+    def __init__(
+        self,
+        depth_std_threshold: float = 0.02,
+        reflectance_window_size: int = 10,
+        hysteresis_count: int = 5,
+        control_rate_hz: float = 10.0,
+    ):
+        self._depth_std_threshold = depth_std_threshold
+        self._hysteresis_count = hysteresis_count
+        self._depth_vars = deque(maxlen=reflectance_window_size)
+        self._reflectances = deque(maxlen=reflectance_window_size)
+        self._current_type = "unknown"
+        self._current_confidence = 0.0
+        self._candidate_type = "unknown"
+        self._candidate_count = 0
+
+    @property
+    def current_surface_type(self) -> str:
+        return self._current_type
+
+    @property
+    def current_confidence(self) -> float:
+        return self._current_confidence
+
+    def update(self, depth_variance: float, reflectance_mean: float) -> TerrainClassification:
+        """Update classifier with sensor measurements."""
+        roughness = min(1.0, depth_variance / (self._depth_std_threshold + 1e-6))
+        reflectance = np.clip(reflectance_mean, 0.0, 1.0)
+
+        self._depth_vars.append(roughness)
+        self._reflectances.append(reflectance)
+
+        avg_roughness = np.mean(list(self._depth_vars)) if self._depth_vars else 0.0
+        avg_reflectance = np.mean(list(self._reflectances)) if self._reflectances else 0.5
+
+        candidate_type, candidate_confidence, speed_scale = self._classify(
+            avg_roughness, avg_reflectance
+        )
+
+        if candidate_type == self._candidate_type:
+            self._candidate_count += 1
+        else:
+            self._candidate_type = candidate_type
+            self._candidate_count = 1
+
+        if self._candidate_count >= self._hysteresis_count:
+            self._current_type = candidate_type
+            self._current_confidence = candidate_confidence
+
+        return TerrainClassification(
+            surface_type=self._current_type,
+            confidence=self._current_confidence,
+            roughness=avg_roughness,
+            reflectance=avg_reflectance,
+            speed_scale=speed_scale,
+        )
+
+    def reset(self) -> None:
+        """Clear buffers and reset to unknown."""
+        self._depth_vars.clear()
+        self._reflectances.clear()
+        self._current_type = "unknown"
+        self._current_confidence = 0.0
+        self._candidate_type = "unknown"
+        self._candidate_count = 0
+
+    def _classify(self, roughness: float, reflectance: float) -> tuple[str, float, float]:
+        """Classify terrain and compute confidence + speed scale."""
+        best_match = None
+        best_score = 0.0
+        best_speed = 1.0
+
+        for name, rough_max, refl_min, refl_max, speed in self._SURFACE_RULES:
+            rough_penalty = max(0.0, (roughness - rough_max) / rough_max) if roughness > rough_max else 0.0
+            refl_penalty = 0.0
+
+            if reflectance < refl_min:
+                refl_penalty = (refl_min - reflectance) / refl_min
+            elif reflectance > refl_max:
+                refl_penalty = (reflectance - refl_max) / (1.0 - refl_max)
+
+            score = 1.0 - (rough_penalty + refl_penalty) * 0.5
+
+            if score > best_score:
+                best_score = score
+                best_match = name
+                best_speed = speed
+
+        confidence = max(0.0, best_score)
+        return best_match or "unknown", confidence, best_speed
+
+    @staticmethod
+    def speed_scale_for_surface(surface_type: str) -> float:
+        """Get speed scale for a surface type."""
+        for name, _, _, _, speed in TerrainClassifier._SURFACE_RULES:
+            if name == surface_type:
+                return speed
+        return 0.75

jetson/ros2_ws/src/saltybot_terrain_classification/setup.cfg

@@ -0,0 +1,4 @@
+[develop]
+script_dir=$base/lib/saltybot_terrain_classification
+[install]
+script_dir=$base/lib/saltybot_terrain_classification

jetson/ros2_ws/src/saltybot_terrain_classification/setup.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+from setuptools import setup, find_packages
+
+setup(
+    name="saltybot_terrain_classification",
+    version="0.1.0",
+    packages=find_packages(),
+    data_files=[
+        ("share/ament_index/resource_index/packages",
+            ["resource/saltybot_terrain_classification"]),
+        ("share/saltybot_terrain_classification", ["package.xml"]),
+    ],
+    install_requires=["setuptools"],
+    zip_safe=True,
+    maintainer="SaltyLab",
+    maintainer_email="seb@example.com",
+    description="Terrain classification using RealSense depth and RPLIDAR (Issue #469)",
+    license="MIT",
+    tests_require=["pytest"],
+    entry_points={
+        "console_scripts": [
+            "terrain_classification_node=saltybot_terrain_classification.terrain_classification_node:main",
+        ],
+    },
+)