ARIA Sensing UWB雷达SoC：儿童存在检测的革命性突破

发表于 更新于 分类于

新闻来源： ARIA Sensing + ALGORIZED 战略合作
发布时间： 2026年3月（MWC 2026）
核心技术： Hydrogen 4×4 UWB雷达SoC + Edge AI

核心突破

世界首款真正的3D UWB雷达SoC

特性 Hydrogen SoC 传统UWB芯片
设计目标 雷达性能优化 安全测距
角分辨率 ~5°（数字波束成形） 15-30°
带宽 1.8 GHz可编程 500 MHz固定
功耗 超低功耗 中等功耗
3D检测 ✅ 原生支持 ❌ 需多芯片

核心差异：

“传统UWB解决方案从未针对高分辨率雷达感知进行优化。Hydrogen改变了这一范式。” —— Alessio Ciaccatori, ARIA Sensing CEO

技术详解

1. UWB雷达原理

什么是UWB（超宽带）？

参数 UWB 传统毫米波雷达
频率范围 3.1-10.6 GHz 60-64 GHz / 76-81 GHz
带宽 >500 MHz（可达1.8 GHz） 200-500 MHz
距离分辨率 <10 cm 15-30 cm
穿透性 强（可穿透座椅、毯子） 弱（被遮挡物阻挡）
功耗 极低（mW级） 中等（W级）

距离分辨率公式：

1
2
3
4
5
6
7
8
9
10
ΔR = c / (2 × B)

其中：
- ΔR：距离分辨率
- c：光速（3×10^8 m/s）
- B：带宽

示例：
- 传统雷达 B = 500 MHz → ΔR = 30 cm
- Hydrogen B = 1.8 GHz → ΔR = 8.3 cm

2. 数字波束成形（Digital Beamforming）

原理： 通过多天线阵列控制波束方向

1
2
3
4
5
6
7
Hydrogen 4×4阵列（4发射 + 4接收）

TX天线间距：λ/2 = 3.75 cm（@ 4 GHz）
RX天线间距：λ/2 = 3.75 cm

虚拟阵列：4×4 = 16个虚拟孔径
角分辨率：~5°

波束成形代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import numpy as np
from scipy import signal

class DigitalBeamformer:
    """
    数字波束成形器
    
    功能：通过相位补偿实现波束指向
    """
    
    def __init__(
        self,
        num_tx: int = 4,
        num_rx: int = 4,
        frequency: float = 4e9,  # 4 GHz
        sampling_rate: float = 10e9  # 10 GSps
    ):
        self.num_tx = num_tx
        self.num_rx = num_rx
        self.frequency = frequency
        self.wavelength = 3e8 / frequency
        self.sampling_rate = sampling_rate
        
        # 天线间距（半波长）
        self.antenna_spacing = self.wavelength / 2
    
    def compute_steering_vector(self, angle_deg: float) -> np.ndarray:
        """
        计算波束指向向量
        
        Args:
            angle_deg: 目标角度（度）
            
        Returns:
            steering_vector: 波束成形权重, shape=(num_tx * num_rx,)
        """
        angle_rad = np.deg2rad(angle_deg)
        
        # 计算每个虚拟天线的相位延迟
        num_virtual = self.num_tx * self.num_rx
        steering_vector = np.zeros(num_virtual, dtype=complex)
        
        for tx in range(self.num_tx):
            for rx in range(self.num_rx):
                # 虚拟天线位置
                virtual_idx = tx * self.num_rx + rx
                
                # 相位延迟（基于位置和角度）
                position = (tx + rx) * self.antenna_spacing
                phase_delay = 2 * np.pi * position * np.sin(angle_rad) / self.wavelength
                
                # 补偿相位（共轭）
                steering_vector[virtual_idx] = np.exp(-1j * phase_delay)
        
        return steering_vector
    
    def beamform(
        self,
        rx_data: np.ndarray,
        angle_range: tuple = (-90, 90),
        angle_step: float = 5.0
    ) -> np.ndarray:
        """
        执行波束成形扫描
        
        Args:
            rx_data: 接收数据, shape=(num_samples, num_rx)
            angle_range: 扫描角度范围
            angle_step: 角度步进
            
        Returns:
            beamformed_data: 波束成形结果, shape=(num_angles, num_samples)
        """
        angles = np.arange(angle_range[0], angle_range[1] + angle_step, angle_step)
        num_samples = rx_data.shape[0]
        beamformed_data = np.zeros((len(angles), num_samples), dtype=complex)
        
        for i, angle in enumerate(angles):
            # 获取波束指向向量
            steering_vector = self.compute_steering_vector(angle)
            
            # 应用波束成形（加权求和）
            for rx in range(self.num_rx):
                beamformed_data[i, :] += rx_data[:, rx] * steering_vector[rx]
        
        return beamformed_data, angles
    
    def detect_target(self, beamformed_data: np.ndarray, angles: np.ndarray) -> dict:
        """
        从波束成形数据中检测目标
        
        Returns:
            detection: 包含角度、距离、强度的字典
        """
        # 计算功率谱
        power = np.abs(beamformed_data) ** 2
        
        # 找到最大功率点
        max_idx = np.unravel_index(np.argmax(power), power.shape)
        
        angle_idx = max_idx[0]
        range_idx = max_idx[1]
        
        # 计算实际距离（基于时间）
        time_delay = range_idx / self.sampling_rate
        distance = 3e8 * time_delay / 2  # 往返距离
        
        return {
            "angle": angles[angle_idx],
            "distance": distance,
            "power": power[angle_idx, range_idx],
            "range_bin": range_idx
        }


# 使用示例
if __name__ == "__main__":
    beamformer = DigitalBeamformer(num_tx=4, num_rx=4)
    
    # 模拟接收数据（含目标在30°，距离1.5m）
    num_samples = 1000
    rx_data = np.zeros((num_samples, 4), dtype=complex)
    
    # 目标回波
    target_angle = 30  # 度
    target_range = 1.5  # 米
    target_delay = int(2 * target_range / 3e8 * beamformer.sampling_rate)
    
    # 添加目标信号
    steering = beamformer.compute_steering_vector(target_angle)
    for rx in range(4):
        rx_data[target_delay, rx] = steering[rx] * 1.0 + np.random.randn() * 0.1
    
    # 波束成形扫描
    beamformed, angles = beamformer.beamform(rx_data)
    
    # 目标检测
    detection = beamformer.detect_target(beamformed, angles)
    
    print(f"检测角度: {detection['angle']:.1f}°")
    print(f"检测距离: {detection['distance']:.2f} m")
    print(f"信号强度: {detection['power']:.2e}")

3. 3D点云生成

Hydrogen的3D检测能力：

1
2
3
4
5
6
7
8
9
传统UWB：2D平面定位（距离 + 角度）
Hydrogen：3D空间定位（距离 + 方位角 + 俯仰角）

技术实现：
- 发射阵列：2×2（水平 + 垂直）
- 接收阵列：2×2（水平 + 垂直）
- 虚拟孔径：4×4 = 16通道
- 俯仰分辨率：~5°
- 方位分辨率：~5°

3D点云代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt

class UWB3DPointcloud:
    """
    UWB 3D点云生成器
    
    基于Hydrogen的4×4阵列配置
    """
    
    def __init__(self):
        # 雷达参数
        self.num_tx = 4
        self.num_rx = 4
        self.frequency = 4e9  # 4 GHz
        self.wavelength = 3e8 / self.frequency
        self.bandwidth = 1.8e9  # 1.8 GHz带宽
        self.range_resolution = 3e8 / (2 * self.bandwidth)  # ~8.3 cm
        
        # 天线阵列配置
        self.tx_positions = np.array([
            [0, 0, 0],
            [self.wavelength/2, 0, 0],
            [0, self.wavelength/2, 0],
            [self.wavelength/2, self.wavelength/2, 0]
        ])
        
        self.rx_positions = np.array([
            [self.wavelength, 0, 0],
            [self.wavelength + self.wavelength/2, 0, 0],
            [self.wavelength, self.wavelength/2, 0],
            [self.wavelength + self.wavelength/2, self.wavelength/2, 0]
        ])
    
    def generate_virtual_array(self) -> np.ndarray:
        """
        生成虚拟阵列位置
        
        Returns:
            virtual_positions: 虚拟天线位置, shape=(16, 3)
        """
        virtual_positions = []
        
        for tx_pos in self.tx_positions:
            for rx_pos in self.rx_positions:
                # 虚拟天线位置 = TX位置 + RX位置
                virtual_positions.append(tx_pos + rx_pos)
        
        return np.array(virtual_positions)
    
    def simulate_cpd_scenario(self) -> np.ndarray:
        """
        模拟CPD场景
        
        场景配置：
        - 后排座椅：距离1.5m，俯仰角-15°
        - 儿童目标：距离1.3m，方位角-20°，俯仰角-12°
        - 呼吸运动：±1 cm
        
        Returns:
            pointcloud: 3D点云数据, shape=(N, 4) [x, y, z, intensity]
        """
        # 儿童位置（极坐标转笛卡尔）
        distance = 1.3  # 米
        azimuth = np.deg2rad(-20)  # 方位角
        elevation = np.deg2rad(-12)  # 俯仰角
        
        x = distance * np.cos(elevation) * np.cos(azimuth)
        y = distance * np.cos(elevation) * np.sin(azimuth)
        z = distance * np.sin(elevation)
        
        # 添加呼吸运动（正弦调制）
        t = np.linspace(0, 4, 100)  # 4秒，100帧
        breathing = 0.01 * np.sin(2 * np.pi * 0.3 * t)  # 0.3 Hz呼吸频率
        
        pointcloud = []
        for i, breath_offset in enumerate(breathing):
            # 更新距离
            current_dist = distance + breath_offset
            
            # 更新位置
            x_i = current_dist * np.cos(elevation) * np.cos(azimuth)
            y_i = current_dist * np.cos(elevation) * np.sin(azimuth)
            z_i = current_dist * np.sin(elevation)
            
            # 雷达反射强度（模拟儿童体型）
            intensity = 0.7 + 0.1 * np.random.randn()
            
            # 添加一些散射点（模拟儿童轮廓）
            for dx, dy, dz in [(0, 0, 0), (-0.1, 0, 0.1), (0.1, 0, -0.05)]:
                pointcloud.append([
                    x_i + dx,
                    y_i + dy,
                    z_i + dz,
                    intensity * (0.8 + 0.2 * np.random.rand())
                ])
        
        return np.array(pointcloud)
    
    def visualize_pointcloud(self, pointcloud: np.ndarray):
        """
        可视化3D点云
        
        Args:
            pointcloud: 点云数据, shape=(N, 4)
        """
        fig = plt.figure(figsize=(12, 8))
        ax = fig.add_subplot(111, projection='3d')
        
        # 提取坐标和强度
        x = pointcloud[:, 0]
        y = pointcloud[:, 1]
        z = pointcloud[:, 2]
        intensity = pointcloud[:, 3]
        
        # 绘制散点图（颜色表示强度）
        scatter = ax.scatter(x, y, z, c=intensity, cmap='hot', s=20, alpha=0.6)
        
        # 添加颜色条
        cbar = plt.colorbar(scatter, ax=ax, shrink=0.6)
        cbar.set_label('反射强度', fontsize=12)
        
        # 设置坐标轴
        ax.set_xlabel('X (m)', fontsize=12)
        ax.set_ylabel('Y (m)', fontsize=12)
        ax.set_zlabel('Z (m)', fontsize=12)
        ax.set_title('UWB雷达CPD 3D点云', fontsize=14)
        
        # 设置视角
        ax.view_init(elev=20, azim=45)
        
        plt.tight_layout()
        plt.savefig('uwb_cpd_pointcloud.png', dpi=150)
        plt.show()
        
        print("点云可视化已保存至 uwb_cpd_pointcloud.png")


# 完整CPD检测流程
if __name__ == "__main__":
    # 1. 初始化雷达
    radar = UWB3DPointcloud()
    
    # 2. 生成虚拟阵列
    virtual_array = radar.generate_virtual_array()
    print(f"虚拟阵列大小: {virtual_array.shape[0]} 通道")
    
    # 3. 模拟CPD场景
    pointcloud = radar.simulate_cpd_scenario()
    print(f"生成点云: {pointcloud.shape[0]} 个点")
    
    # 4. 可视化
    radar.visualize_pointcloud(pointcloud)
    
    # 5. 性能统计
    print(f"\nHydrogen SoC性能：")
    print(f"  距离分辨率: {radar.range_resolution * 100:.1f} cm")
    print(f"  带宽: {radar.bandwidth / 1e9:.1f} GHz")
    print(f"  虚拟阵列: {len(virtual_array)} 通道")

4. Edge AI集成

ALGORIZED嵌入式AI引擎：

功能 描述
人数统计 实时统计车内人数
微动作检测 检测呼吸、心跳等微动
行为模式识别 识别异常行为
婴儿监控 专属婴儿检测算法

边缘AI推理流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
import numpy as np
import onnxruntime as ort

class CPDEdgeAI:
    """
    儿童存在检测边缘AI引擎
    
    运行在Hydrogen SoC内置AI加速器上
    """
    
    def __init__(self, model_path: str = "cpd_detector.onnx"):
        # 加载ONNX模型
        self.session = ort.InferenceSession(model_path)
        
        # 输入配置
        self.input_name = self.session.get_inputs()[0].name
        self.input_shape = self.session.get_inputs()[0].shape
        
        # 输出配置
        self.output_names = [o.name for o in self.session.get_outputs()]
    
    def preprocess(self, radar_data: np.ndarray) -> np.ndarray:
        """
        预处理雷达数据
        
        Args:
            radar_data: 原始雷达数据, shape=(num_chirps, num_samples, num_rx)
            
        Returns:
            preprocessed: 预处理后的数据
        """
        # 1. Range-FFT
        range_fft = np.fft.fft(radar_data, axis=1)
        
        # 2. Doppler-FFT
        doppler_fft = np.fft.fft(range_fft, axis=0)
        
        # 3. 波束成形
        # （此处简化，实际需要完整的波束成形处理）
        
        # 4. 归一化
        normalized = np.abs(doppler_fft) / np.max(np.abs(doppler_fft))
        
        # 5. 调整维度
        if len(normalized.shape) == 3:
            normalized = normalized[np.newaxis, ...]  # 添加batch维度
        
        return normalized.astype(np.float32)
    
    def detect(self, radar_data: np.ndarray) -> dict:
        """
        执行CPD检测
        
        Args:
            radar_data: 雷达数据
            
        Returns:
            result: 检测结果
        """
        # 预处理
        input_data = self.preprocess(radar_data)
        
        # 推理
        outputs = self.session.run(
            self.output_names,
            {self.input_name: input_data}
        )
        
        # 解析输出
        # 假设输出格式：[child_presence, bbox, vital_signs]
        child_presence = outputs[0]  # (1,) 概率值
        bbox = outputs[1] if len(outputs) > 1 else None  # (1, 4) 边界框
        vital_signs = outputs[2] if len(outputs) > 2 else None  # (1, 3) [呼吸率, 心率, 距离]
        
        return {
            "child_detected": bool(child_presence[0] > 0.5),
            "confidence": float(child_presence[0]),
            "bbox": bbox[0].tolist() if bbox is not None else None,
            "vital_signs": {
                "breathing_rate": float(vital_signs[0][0]) if vital_signs is not None else None,
                "heart_rate": float(vital_signs[0][1]) if vital_signs is not None else None,
                "distance": float(vital_signs[0][2]) if vital_signs is not None else None
            }
        }
    
    def monitor_continuous(self, radar_stream, interval_ms: int = 100):
        """
        持续监控模式
        
        Args:
            radar_stream: 雷达数据流
            interval_ms: 检测间隔
        """
        import time
        
        print("CPD监控启动...")
        
        for i, radar_frame in enumerate(radar_stream):
            result = self.detect(radar_frame)
            
            if result["child_detected"]:
                print(f"[{i}] ⚠️ 检测到儿童！")
                print(f"  置信度: {result['confidence']:.2%}")
                
                if result["vital_signs"]["breathing_rate"]:
                    print(f"  呼吸率: {result['vital_signs']['breathing_rate']:.1f} 次/分")
                    print(f"  心率: {result['vital_signs']['heart_rate']:.1f} 次/分")
                    print(f"  距离: {result['vital_signs']['distance']:.2f} m")
            else:
                if i % 10 == 0:  # 每10帧打印一次
                    print(f"[{i}] 车内无儿童")
            
            time.sleep(interval_ms / 1000)


# 部署示例
if __name__ == "__main__":
    # 初始化CPD引擎
    cpd = CPDEdgeAI("cpd_detector.onnx")
    
    # 模拟雷达数据流
    def radar_stream_generator(num_frames: int = 100):
        for _ in range(num_frames):
            # 模拟雷达数据
            # shape: (num_chirps=128, num_samples=256, num_rx=4)
            frame = np.random.randn(128, 256, 4).astype(np.float32)
            
            # 添加儿童目标（在第50帧后）
            if _ > 50:
                # 添加呼吸信号（低频多普勒）
                breathing_signal = 0.1 * np.sin(2 * np.pi * 0.3 * np.arange(128) / 128)
                frame[:, 100, :] += breathing_signal[:, np.newaxis]
            
            yield frame
    
    # 启动监控
    radar_stream = radar_stream_generator(100)
    cpd.monitor_continuous(radar_stream, interval_ms=100)

Euro NCAP CPD要求对比

Euro NCAP 2026要求 Hydrogen方案 符合性
检测新生儿 ✅ 微动作检测（呼吸） ✅
检测覆盖后座 ✅ 3D波束成形覆盖 ✅
遮挡物穿透 ✅ UWB穿透座椅/毯子 ✅
实时报警 ✅ <3秒检测延迟 ✅
误报率 <5% ⚠️ 待验证 待测试

Hydrogen优势：

对比项 UWB (Hydrogen) 60GHz毫米波 摄像头
遮挡穿透 ✅ 强 ⚠️ 中等 ❌ 无
隐私保护 ✅ 无图像 ✅ 无图像 ⚠️ 有图像
成本 💰 中等 💰 中等 💰 低
功耗 ✅ 极低 ⚠️ 中等 ✅ 低
分辨率 ⚠️ ~8cm ✅ ~5cm ✅ 高
呼吸检测 ✅ 支持 ✅ 支持 ⚠️ 有限

IMS开发启示

1. 传感器选型

推荐方案：UWB + 摄像头融合

方案 应用场景
UWB独占 隐私敏感场景、遮挡检测
摄像头独占 成本敏感、高分辨率需求
UWB+摄像头融合 高可靠CPD（推荐）

融合架构：

1
2
3
4
5
6
7
UWB雷达（Hydrogen）
    ↓ 呼吸信号、距离、方位角
    ↓
数据融合层（卡尔曼滤波）
    ↑
摄像头（RGB-IR）
    ↑ 儿童轮廓、姿态

2. 硬件部署位置

推荐安装位置：

位置 优点 缺点
车顶中部 视野最佳 安装复杂
后视镜 集成方便 后排盲区
B柱 侧向检测 覆盖有限
后排座椅 隐蔽、近距 视野受限

Hydrogen建议： 车顶中部，波束成形覆盖全座舱

3. 算法开发路线

阶段 功能 时间
Phase 1 基础CPD（人数检测） 3个月
Phase 2 呼吸/心跳监测 2个月
Phase 3 行为模式识别 3个月
Phase 4 Euro NCAP认证测试 2个月

4. 供应链对接

ARIA Sensing联系信息：

ALGORIZED Edge AI：

  • 功能：嵌入式AI推理引擎
  • 集成：与Hydrogen SoC深度优化

竞品对比

方案 技术 距离分辨率 功耗 3D能力 成本
Hydrogen UWB 8 cm <50 mW ✅ 原生 $$
TI IWR6843 60GHz mmWave 5 cm ~1 W ✅ $$
Acconeer 60GHz脉冲雷达 3 cm 200 mW ⚠️ 有限 $$$
摄像头方案 RGB-IR N/A 500 mW ✅ $

Hydrogen差异化：

  1. 功耗最低： 适合常电监控
  2. 穿透最强： UWB天然优势
  3. 成本适中： 单芯片解决方案
  4. AI集成： 与ALGORIZED深度合作

总结

维度 Hydrogen SoC表现
技术创新 世界首款3D UWB雷达SoC
CPD适用性 ✅ 满足Euro NCAP 2026
功耗优势 ✅ 极低功耗，支持常电
穿透能力 ✅ 超越毫米波和摄像头
商业成熟度 ⚠️ 2026年量产，待验证

IMS行动建议：

  1. 对接ARIA Sensing获取Hydrogen样片
  2. 评估与现有DMS系统的集成方案
  3. 制定UWB+摄像头融合的技术路线
  4. 准备Euro NCAP CPD测试认证

发布时间： 2026-04-20
标签： #CPD #UWB雷达 #儿童检测 #EuroNCAP #边缘AI