感知系统：传感器融合

人形机器人的感知系统如同人类的”五官”，通过摄像头、激光雷达、IMU、力传感器等设备感知环境。但单一传感器存在局限，多传感器融合成为必然选择。本文深入解析人形机器人感知系统的硬件选型、融合算法与核心应用。

一、感知系统架构概览

1.1 人类感知 vs 机器人感知

人类感知系统                    机器人感知系统
├── 眼睛（视觉）               ├── 摄像头（RGB、深度、事件）
├── 耳朵（听觉）               ├── 麦克风阵列
├── 皮肤（触觉）               ├── 力/力矩传感器、电子皮肤
├── 前庭（平衡）               ├── IMU（加速度计 + 陀螺仪）
├── 肌肉（本体感觉）           ├── 编码器、电流传感器
└── 鼻子（嗅觉）               └── 气体传感器（较少用）

1.2 人形机器人传感器配置

典型配置（以 Tesla Optimus 为例）：

Tesla Optimus 感知系统
├── 视觉系统
│   ├── 头部：2× 摄像头（主视）
│   ├── 躯干：4× 摄像头（环视）
│   └── 手部：2× 摄像头（手眼）
├── 深度感知
│   └── 结构光/ToF 深度相机
├── 惯性测量
│   └── IMU×2（躯干 + 头部，冗余）
├── 力觉感知
│   ├── 腕部：六维力传感器×2
│   └── 脚踝：六维力传感器×2
├── 本体感知
│   ├── 关节编码器×40
│   └── 电机电流传感器×40
└── 其他
    ├── 麦克风阵列（语音交互）
    └── 温度传感器（电池、电机）

1.3 传感器性能对比

二、视觉感知

2.1 摄像头类型

RGB 摄像头

RGB 摄像头参数选择
├── 分辨率
│   ├── 低：640×480（VGA），用于快速检测
│   ├── 中：1920×1080（FHD），通用场景
│   └── 高：4K，精细识别
├── 帧率
│   ├── 30fps：一般应用
│   ├── 60fps：快速运动
│   └── 120fps+：高速捕捉
├── 视场角（FOV）
│   ├── 窄角（30-60°）：远距离识别
│   ├── 标准（60-90°）：通用人眼视角
│   └── 广角（90-120°）：近距离大范围
└── 曝光控制
    ├── 自动曝光：适应光照变化
    └── 全局快门：避免运动模糊

深度相机

三种主流技术：

Intel RealSense D435 参数：

D435 技术规格
├── 深度分辨率：1280×720 @ 90fps
├── RGB 分辨率：1920×1080 @ 30fps
├── 深度精度：2mm @ 2m
├── 有效距离：0.3-10m
├── FOV：87°×58°
├── 接口：USB 3.0
└── 尺寸：90×25×25mm

事件相机（Event Camera）

新型传感器：

• 原理：每个像素独立响应亮度变化
• 优点：
  • 超高帧率（等效 10000fps+）
  • 无运动模糊
  • 高动态范围（140dB vs 60dB）
  • 低功耗
• 缺点：
  • 输出是事件流，需特殊算法
  • 成本高
  • 生态不成熟

应用场景：

• 高速运动跟踪
• 低延迟避障
• 极端光照条件

2.2 视觉算法

物体检测

# YOLOv8 物体检测示例
from ultralytics import YOLO

# 加载模型
model = YOLO('yolov8n.pt')  # nano 版本，速度快

# 推理
results = model(image)

# 解析结果
for result in results:
    boxes = result.boxes  # 边界框
    for box in boxes:
        x1, y1, x2, y2 = box.xyxy[0]
        class_id = int(box.cls[0])
        confidence = float(box.conf[0])
        
        print(f"检测到：{class_id}, 置信度：{confidence:.2f}")

# 性能：RTX 4090, 100+ FPS

常用模型对比：

语义分割

# DeepLabV3+ 语义分割
import torch
from torchvision.models.segmentation import deeplabv3_resnet101

# 加载模型
model = deeplabv3_resnet101(pretrained=True)
model.eval()

# 推理
with torch.no_grad():
    output = model(image)['out'][0]

# 解析分割结果
segmentation = output.argmax(0)

# 类别映射
classes = {
    0: '背景',
    1: '人',
    2: '桌子',
    3: '椅子',
    # ...
}

应用场景：

• 场景理解
• 可通行区域检测
• 物体边界精确定位

6D 姿态估计

任务：估计物体的 3D 位置 (x, y, z) 和旋转 (roll, pitch, yaw)

# DenseFusion 6D 姿态估计
class PoseEstimator:
    def __init__(self):
        self.model = load_pretrained('densefusion')
    
    def estimate(self, rgb_image, depth_image):
        """
        估计物体 6D 姿态
        输入：RGB 图像 + 深度图
        输出：4×4 变换矩阵
        """
        # 特征提取
        rgb_features = self.rgb_encoder(rgb_image)
        depth_features = self.depth_encoder(depth_image)
        
        # 特征融合
        fused = self.fusion_module(rgb_features, depth_features)
        
        # 姿态回归
        translation = self.translation_head(fused)  # [x, y, z]
        rotation = self.rotation_head(fused)  # 四元数 [x, y, z, w]
        
        # 构建变换矩阵
        T = self.quaternion_to_matrix(rotation)
        T[:3, 3] = translation
        
        return T

# 精度：位置误差<2cm，角度误差<5°

2.3 视觉 SLAM

ORB-SLAM3

架构：

ORB-SLAM3 系统架构
├── 追踪线程（Tracking）
│   ├── 特征提取（ORB 特征）
│   ├── 特征匹配
│   ├── 位姿估计（PnP）
│   └── 局部 Bundle Adjustment
├── 建图线程（Local Mapping）
│   ├── 关键帧选择
│   ├── 地图点创建
│   ├── 局部 BA 优化
│   └── 冗余点剔除
├── 回环检测线程（Loop Closing）
│   ├── 词袋模型检索
│   ├── 几何验证
│   ├── 位姿图优化
│   └── 全局 BA
└── 重定位（Relocalization）
    └── 跟踪丢失时重新定位

性能指标：

• 精度：1-5cm（室内）
• 速度：30-60fps（单目）
• 鲁棒性：可处理快速运动、光照变化

视觉 - 惯性 SLAM（VINS）

VINS-Mono 架构：

graph TB
    subgraph 传感器输入
        A[单目摄像头]
        B[IMU]
    end
    
    subgraph 前端
        C[特征提取与追踪]
        D[IMU 预积分]
    end
    
    subgraph 后端
        E[紧耦合优化]
        F[滑动窗口 BA]
    end
    
    subgraph 输出
        G[相机位姿]
        H[稀疏地图]
    end
    
    A --> C
    B --> D
    C --> E
    D --> E
    E --> F
    F --> G
    F --> H

优势：

• IMU 提供高频运动预测
• 解决视觉退化场景（纹理少、快速运动）
• 尺度可观（单目无法估计尺度）

精度：

• 位置误差：<1% 行进距离
• 角度误差：<0.1°/s

三、激光雷达感知

3.1 激光雷达类型

机械旋转式

代表产品：Velodyne HDL-64E

HDL-64E 参数
├── 线数：64 线
├── 测距：120m（10% 反射率）
├── 精度：±2cm
├── 视场角：360°水平，26.9°垂直
├── 扫描频率：10Hz
├── 点数/秒：1,300,000
└── 成本：$80,000+（已停产）

特点：

• 360° 视场
• 技术成熟
• 成本高、体积大

固态激光雷达

代表产品：Ouster OS1、Livox Avia

Livox Avia 参数
├── 线数：等效 144 线
├── 测距：190m（10% 反射率）
├── 精度：±2cm
├── 视场角：70.4°×4.5°
├── 扫描频率：10Hz
├── 点数/秒：720,000
└── 成本：$5,000+

特点：

• 无运动部件，可靠性高
• 成本较低
• 视场角有限

Flash 激光雷达

代表产品：Leddar Vu8

原理：面阵发射，单次闪光获取整帧

特点：

• 帧率高
• 距离短（<50m）
• 适合近距离避障

3.2 点云处理

点云预处理

import open3d as o3d
import numpy as np

# 加载点云
pcd = o3d.io.read_point_cloud('scan.pcd')

# 1. 降采样（体素网格）
pcd_down = pcd.voxel_down_sample(voxel_size=0.05)

# 2. 去噪（统计滤波）
cl, ind = pcd_down.remove_statistical_outlier(
    nb_neighbors=20,
    std_ratio=2.0
)
pcd_clean = pcd_down.select_by_index(ind)

# 3. 地面分割（RANSAC）
plane_model, inliers = pcd_clean.segment_plane(
    distance_threshold=0.1,
    ransac_n=3,
    num_iterations=1000
)

# 分离地面和非地面点
ground = pcd_clean.select_by_index(inliers)
objects = pcd_clean.select_by_index(list(set(pcd_clean.indices) - set(inliers)))

物体聚类

from sklearn.cluster import DBSCAN

# DBSCAN 聚类
def cluster_point_cloud(points, eps=0.5, min_samples=10):
    """
    点云聚类
    points: Nx3 点云坐标
    eps: 邻域半径
    min_samples: 最小点数
    """
    clustering = DBSCAN(eps=eps, min_samples=min_samples)
    labels = clustering.fit_predict(points)
    
    # 提取每个簇
    clusters = {}
    for i, label in enumerate(labels):
        if label == -1:  # 噪声点
            continue
        if label not in clusters:
            clusters[label] = []
        clusters[label].append(points[i])
    
    return clusters

# 应用
clusters = cluster_point_cloud(np.asarray(objects.points))
print(f"检测到 {len(clusters)} 个物体")

3D 目标检测

PointNet++ 架构：

import torch
from pointnet2_ops import pointnet2_utils

class PointNet2Detector(nn.Module):
    def __init__(self):
        super().__init__()
        # 特征提取
        self.sa1 = PointnetSAModule(...)
        self.sa2 = PointnetSAModule(...)
        self.sa3 = PointnetSAModule(...)
        
        # 检测头
        self.detection_head = nn.Sequential(
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 9 + num_classes)  # [x,y,z,l,w,h,r,θ,φ] + cls
        )
    
    def forward(self, points):
        # 多层特征提取
        l1_xyz, l1_features = self.sa1(points)
        l2_xyz, l2_features = self.sa2(l1_xyz, l1_features)
        l3_xyz, l3_features = self.sa3(l2_xyz, l2_features)
        
        # 检测
        predictions = self.detection_head(l3_features)
        
        return predictions

# 数据集：KITTI, Waymo, nuScenes

四、惯性测量单元（IMU）

4.1 IMU 原理

组成：

• 加速度计：测量线性加速度
• 陀螺仪：测量角速度

输出：

IMU 数据
├── 加速度：[ax, ay, az] (m/s²)
├── 角速度：[wx, wy, wz] (rad/s)
└── （可选）磁力计：[mx, my, mz] (μT)

4.2 IMU 数据处理

预积分

class IMUPreintegrator:
    def __init__(self, acc_noise, gyro_noise):
        self.acc_noise = acc_noise
        self.gyro_noise = gyro_noise
        self.reset()
    
    def reset(self):
        self.delta_p = np.zeros(3)  # 位置增量
        self.delta_v = np.zeros(3)  # 速度增量
        self.delta_q = np.array([1, 0, 0, 0])  # 姿态增量（四元数）
    
    def integrate(self, acc, gyro, dt):
        """
        IMU 预积分
        acc: 加速度测量值
        gyro: 角速度测量值
        dt: 时间间隔
        """
        # 更新姿态（角速度积分）
        omega = gyro * dt
        dq = self.angle_to_quaternion(omega)
        self.delta_q = self.quaternion_multiply(self.delta_q, dq)
        
        # 更新速度（加速度积分）
        # a_global = R * a_local + g
        acc_global = self.rotate_vector(self.delta_q, acc)
        self.delta_v += acc_global * dt
        
        # 更新位置
        self.delta_p += self.delta_v * dt + 0.5 * acc_global * dt * dt
        
        return self.delta_p, self.delta_v, self.delta_q

姿态估计（互补滤波）

class ComplementaryFilter:
    def __init__(self, alpha=0.98):
        self.alpha = alpha  # 滤波系数
        self.pitch = 0
        self.roll = 0
        self.yaw = 0
    
    def update(self, acc, gyro, dt):
        """
        互补滤波融合加速度计和陀螺仪
        """
        # 从加速度计计算姿态（低频可靠）
        acc_pitch = np.arctan2(acc[0], np.sqrt(acc[1]**2 + acc[2]**2))
        acc_roll = np.arctan2(-acc[1], acc[2])
        
        # 从陀螺仪积分姿态（高频可靠）
        self.pitch += gyro[1] * dt
        self.roll += gyro[0] * dt
        self.yaw += gyro[2] * dt
        
        # 互补滤波融合
        self.pitch = self.alpha * self.pitch + (1 - self.alpha) * acc_pitch
        self.roll = self.alpha * self.roll + (1 - self.alpha) * acc_roll
        
        # yaw 无法从加速度计获得，只用陀螺仪
        # （需要磁力计或视觉校正漂移）
        
        return self.pitch, self.roll, self.yaw

扩展卡尔曼滤波（EKF）

class EKF_IMU:
    def __init__(self):
        # 状态：[pos, vel, quat, bias_acc, bias_gyro]
        self.x = np.zeros(16)
        
        # 协方差
        self.P = np.eye(16)
        
        # 过程噪声
        self.Q = np.diag([0.01]*16)
        
        # 测量噪声
        self.R = np.diag([0.1]*6)  # 加速度 + 角速度
    
    def predict(self, u, dt):
        """预测步"""
        # 状态转移
        self.x = self.state_transition(self.x, u, dt)
        
        # 雅可比矩阵
        F = self.compute_jacobian(self.x, u, dt)
        
        # 协方差预测
        self.P = F @ self.P @ F.T + self.Q
    
    def update(self, z):
        """更新步"""
        # 预测测量
        z_pred = self.measurement_model(self.x)
        
        # 雅可比
        H = self.measurement_jacobian(self.x)
        
        # 卡尔曼增益
        S = H @ self.P @ H.T + self.R
        K = self.P @ H.T @ np.linalg.inv(S)
        
        # 状态更新
        self.x = self.x + K @ (z - z_pred)
        
        # 协方差更新
        self.P = (np.eye(16) - K @ H) @ self.P

五、力觉感知

5.1 力传感器类型

六维力/力矩传感器

测量：三个力 (Fx, Fy, Fz) + 三个力矩 (Tx, Ty, Tz)

代表产品：

安装位置：

• 腕部：测量手部操作力
• 脚踝：测量地面反作用力
• 关节：测量关节扭矩（通过电机电流估算）

5.2 力控算法

阻抗控制

class ImpedanceController:
    """
    阻抗控制：让机器人表现得像弹簧 - 阻尼系统
    F = K * (x_desired - x_actual) + D * (v_desired - v_actual)
    """
    def __init__(self, K, D):
        self.K = K  # 刚度矩阵 (3×3)
        self.D = D  # 阻尼矩阵 (3×3)
    
    def compute_force(self, x_desired, x_actual, v_desired, v_actual):
        # 位置误差
        pos_error = x_desired - x_actual
        
        # 速度误差
        vel_error = v_desired - v_actual
        
        # 计算期望力
        F = self.K @ pos_error + self.D @ vel_error
        
        return F
    
    def apply(self, F_desired, J):
        """
        将期望力转换为关节扭矩
        τ = J^T * F
        """
        tau = J.T @ F_desired
        return tau

导纳控制

class AdmittanceController:
    """
    导纳控制：测量外力，计算期望运动
    M * x_ddot + D * x_dot + K * x = F_external
    """
    def __init__(self, M, D, K, dt):
        self.M = M  # 虚拟质量
        self.D = D  # 虚拟阻尼
        self.K = K  # 虚拟刚度
        self.dt = dt
    
    def update(self, F_external, x_current, v_current):
        # 计算期望加速度
        # M * a = F_ext - D * v - K * x
        a_desired = np.linalg.inv(self.M) @ (
            F_external - self.D @ v_current - self.K @ x_current
        )
        
        # 积分得到速度和位置
        v_desired = v_current + a_desired * self.dt
        x_desired = x_current + v_desired * self.dt
        
        return x_desired, v_desired

力位混合控制

class HybridForcePositionController:
    """
    力位混合控制：某些方向力控，某些方向位置控
    """
    def __init__(self, selection_matrix):
        # 选择矩阵：对角线为 1 表示力控，0 表示位置控
        self.S = selection_matrix
    
    def compute(self, x_desired, F_desired, x_actual, F_actual, J):
        # 分解到力控和位置控子空间
        S_force = np.diag(self.S.diagonal())
        S_pos = np.diag(1 - self.S.diagonal())
        
        # 力控部分
        F_error = F_desired - F_actual
        tau_force = J.T @ S_force @ F_error
        
        # 位置控部分
        x_error = x_desired - x_actual
        tau_pos = J.T @ S_pos @ x_error
        
        # 合成
        tau = tau_force + tau_pos
        
        return tau

# 应用示例：桌面擦拭
# - Z 方向：力控（保持恒定压力）
# - X, Y 方向：位置控（按轨迹移动）
selection = np.diag([0, 0, 1])  # Z 方向力控

六、多传感器融合

6.1 融合架构

松耦合

松耦合架构

传感器 1 → 状态估计 1 ┐
传感器 2 → 状态估计 2 ├→ 融合 → 最终状态
传感器 3 → 状态估计 3 ┘

优点：模块化，易于实现
缺点：信息损失，精度较低

紧耦合

紧耦合架构

传感器 1 ┐
传感器 2 ├→ 联合优化 → 最终状态
传感器 3 ┘

优点：信息充分利用，精度高
缺点：计算复杂，实现困难

6.2 卡尔曼滤波融合

class SensorFusionEKF:
    """
    多传感器融合的扩展卡尔曼滤波
    """
    def __init__(self):
        # 状态：[pos, vel, quat, bias]
        self.x = np.zeros(16)
        self.P = np.eye(16)
        
        # 传感器噪声参数
        self.R_imu = np.diag([0.01]*6)
        self.R_gps = np.diag([1.0]*3)
        self.R_vision = np.diag([0.1]*6)
    
    def predict(self, imu_data, dt):
        """IMU 预测步"""
        acc, gyro = imu_data[:3], imu_data[3:]
        
        # 状态转移
        self.x = self.imu_model(self.x, acc, gyro, dt)
        
        # 协方差预测
        F = self.compute_jacobian(self.x, acc, gyro, dt)
        self.P = F @ self.P @ F.T + self.Q
    
    def update_imu(self, imu_data):
        """IMU 更新（可选，用于校正 bias）"""
        H = self.imu_measurement_jacobian(self.x)
        self._ekf_update(imu_data, H, self.R_imu)
    
    def update_gps(self, gps_data):
        """GPS 更新"""
        H = self.gps_measurement_jacobian(self.x)
        self._ekf_update(gps_data, H, self.R_gps)
    
    def update_vision(self, vision_data):
        """视觉更新"""
        H = self.vision_measurement_jacobian(self.x)
        self._ekf_update(vision_data, H, self.R_vision)
    
    def _ekf_update(self, z, H, R):
        """EKF 更新步骤"""
        z_pred = H @ self.x
        y = z - z_pred  # 新息
        S = H @ self.P @ H.T + R
        K = self.P @ H.T @ np.linalg.inv(S)
        
        self.x = self.x + K @ y
        self.P = (np.eye(16) - K @ H) @ self.P

6.3 因子图优化

# 使用 GTSAM 进行因子图优化
import gtsam
from gtsam import Values, NonlinearFactorGraph

# 创建因子图
graph = NonlinearFactorGraph()

# 先验因子
graph.add(gtsam.PriorFactorPose3(
    0,  # 关键帧 0
    gtsam.Pose3(...),  # 初始位姿
    gtsam.noiseModel.Diagonal.Variances([0.01]*6)
))

# IMU 因子
for i in range(num_frames-1):
    graph.add(gtsam.ImuFactor(
        i, i+1,  # 连接的关键帧
        imu_measurements[i],
        gtsam.noiseModel.Diagonal.Variances([0.01]*6)
    ))

# 视觉因子
for i, (keyframe, landmark) in enumerate(observations):
    graph.add(gtsam.GenericProjectionFactorCal3_S2(
        keyframe, landmark,
        noiseModel,
        camera,
        pixel_measurement
    ))

# 回环因子
graph.add(gtsam.BetweenFactorPose3(
    loop_i, loop_j,
    relative_pose,
    noiseModel
))

# 优化
initial_estimate = Values()
# ... 初始化估计

optimizer = gtsam.LevenbergMarquardtOptimizer(graph, initial_estimate)
result = optimizer.optimize()

6.4 融合策略

典型融合策略（以 VIO 为例）

┌─────────────────────────────────────┐
│ 传感器数据采集                       │
│ - 摄像头：30fps                     │
│ - IMU: 200Hz                        │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ IMU 预积分（200Hz）                  │
│ - 高频位姿预测                      │
│ - 运动补偿                          │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 视觉特征提取与追踪（30fps）          │
│ - ORB 特征提取                      │
│ - 光流追踪                          │
│ - 深度估计                          │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 紧耦合优化（30fps）                  │
│ - 联合 BA 优化                       │
│ - IMU bias 估计                     │
│ - 尺度恢复                          │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 输出                                │
│ - 6DoF 位姿                          │
│ - 速度                              │
│ - IMU bias                          │
│ - 稀疏地图                          │
└─────────────────────────────────────┘

七、感知系统应用

7.1 导航与避障

导航感知流程
┌─────────────────────────────────────┐
│ 1. 定位                              │
│    - VIO/LIO 估计位姿                │
│    - 全局重定位（回环检测）          │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 2. 建图                              │
│    - 占据网格地图（Occupancy Grid）  │
│    - 点云地图                        │
│    - 语义地图                        │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 3. 路径规划                          │
│    - 全局规划：A*, RRT              │
│    - 局部规划：TEB, DWA             │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 4. 避障                              │
│    - 动态障碍物检测                  │
│    - 速度障碍物（VO）                │
│    - 紧急停止                        │
└─────────────────────────────────────┘

7.2 物体抓取

抓取感知流程
┌─────────────────────────────────────┐
│ 1. 物体检测                          │
│    - YOLO 检测物体类别和位置          │
│    - 实例分割获取精确边界            │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 2. 6D 姿态估计                       │
│    - DenseFusion 估计位姿            │
│    - Refine 优化                     │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 3. 抓取点检测                        │
│    - GPD 生成候选抓取点              │
│    - 评分排序                        │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 4. 运动规划                          │
│    - 逆运动学求解                    │
│    - 碰撞检测                        │
│    - 轨迹优化                        │
└─────────────────────────────────────┘

7.3 人机交互

HRI 感知流程
┌─────────────────────────────────────┐
│ 1. 人体检测                          │
│    - 人体关键点检测（OpenPose）      │
│    - 3D 人体姿态估计                 │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 2. 意图识别                          │
│    - 手势识别                        │
│    - 视线追踪                        │
│    - 行为预测                        │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 3. 语音交互                          │
│    - 语音识别（ASR）                 │
│    - 语义理解（NLU）                 │
│    - 语音合成（TTS）                 │
└──────────────┬──────────────────────┘
               ▼
┌─────────────────────────────────────┐
│ 4. 安全监控                          │
│    - 距离监控                        │
│    - 碰撞预测                        │
│    - 急停触发                        │
└─────────────────────────────────────┘

八、传感器选型建议

8.1 按应用场景选型

8.2 按性能需求选型

性能 - 成本权衡

高端配置（研究/高端商用）
├── 摄像头：Intel RealSense D455（¥2,000）
├── 激光：Ouster OS1-64（¥50,000）
├── IMU：Xsens MTi-670（¥20,000）
└── 力传感器：ATI Mini45（¥25,000）
总计：~¥100,000

中端配置（商用/教育）
├── 摄像头：Intel RealSense D435i（¥1,500）
├── 激光：Livox Mid-40（¥15,000）
├── IMU：MPU-9250（¥200）
└── 力传感器：国产六维力（¥5,000）
总计：~¥25,000

入门配置（教育/ hobby）
├── 摄像头：ZED Mini（¥3,000）
├── 激光：RPLIDAR A1（¥1,500）
├── IMU：MPU-6050（¥50）
└── 力传感器：电流估算（¥0）
总计：~¥5,000

8.3 国产替代方案

九、未来趋势

9.1 技术趋势

1. 4D 毫米波雷达：增加高度信息，成本低于激光
2. 事件相机普及：高动态、低延迟场景
3. 神经辐射场（NeRF）：隐式场景表示
4. 端到端感知：原始数据→动作，减少中间表示

9.2 集成趋势

• 多传感器一体化：单设备集成多种传感器
• 嵌入式 AI：传感器端智能处理
• 标准化接口：ROS 2、时间同步

9.3 成本趋势

传感器成本下降预测

| 传感器 | 2024 年 | 2026 年 | 2030 年 |
|--------|---------|---------|---------|
| 3D 激光 | ¥50,000 | ¥20,000 | ¥5,000 |
| 深度相机 | ¥2,000 | ¥1,000 | ¥500 |
| 高性能 IMU | ¥20,000 | ¥10,000 | ¥2,000 |
| 六维力传感器 | ¥25,000 | ¥10,000 | ¥5,000 |

十、总结

10.1 核心要点

1. 多传感器融合是必然：单一传感器无法满足需求
2. 视觉是核心：信息丰富，成本低
3. IMU 是关键补充：高频、解决运动模糊
4. 力觉不可或缺：物理交互必备
5. 融合算法决定上限：卡尔曼滤波、因子图优化

10.2 设计原则

感知系统设计原则

1. 冗余设计：关键传感器备份
2. 时间同步：硬件触发、PTP 协议
3. 外参标定：定期校准
4. 故障检测：传感器健康监控
5. 计算匹配：算法复杂度与算力匹配

10.3 长期展望

感知系统正朝着更便宜、更智能、更集成的方向发展。随着技术进步，人形机器人将拥有超越人类的感知能力：

• 360° 无死角：全方位环境感知
• 毫米级精度：精确定位和操作
• 毫秒级响应：快速反应和避障
• 多模态融合：视觉、听觉、触觉统一

感知能力的提升，将直接推动人形机器人从”看得见”到”看得懂”，最终实现”看得准、做得对”。

参考资料：

• ORB-SLAM3 论文
• VINS-Mono 论文
• PointNet++ 论文
• Intel RealSense 产品文档
• GTSAM 库文档