From ab5335afd07189ed051da1e3b4a1852719087809 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:37:48 +0800 Subject: [PATCH 1/4] Add files via upload --- .../CMakeLists.txt | 18 ++ .../ride_comfort_transmissibility/README.md | 159 +++++++++++ .../config/ride_comfort_transmissibility.yaml | 21 ++ .../launch/main.launch | 46 ++++ .../ride_comfort_transmissibility/package.xml | 18 ++ .../scripts/main.py | 17 ++ .../scripts/ride_core.py | 247 ++++++++++++++++++ .../scripts/ride_node.py | 111 ++++++++ 8 files changed, 637 insertions(+) create mode 100644 src/ground/ride_comfort_transmissibility/CMakeLists.txt create mode 100644 src/ground/ride_comfort_transmissibility/README.md create mode 100644 src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml create mode 100644 src/ground/ride_comfort_transmissibility/launch/main.launch create mode 100644 src/ground/ride_comfort_transmissibility/package.xml create mode 100644 src/ground/ride_comfort_transmissibility/scripts/main.py create mode 100644 src/ground/ride_comfort_transmissibility/scripts/ride_core.py create mode 100644 src/ground/ride_comfort_transmissibility/scripts/ride_node.py diff --git a/src/ground/ride_comfort_transmissibility/CMakeLists.txt b/src/ground/ride_comfort_transmissibility/CMakeLists.txt new file mode 100644 index 0000000000..4f2d66baab --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/CMakeLists.txt @@ -0,0 +1,18 @@ +cmake_minimum_required(VERSION 3.0.2) +project(ride_comfort_transmissibility) + +find_package(catkin REQUIRED) + +catkin_package() + +catkin_install_python(PROGRAMS + scripts/main.py + scripts/ride_core.py + scripts/ride_node.py + DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +) + +install(DIRECTORY launch config + DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} + USE_SOURCE_PERMISSIONS +) diff --git a/src/ground/ride_comfort_transmissibility/README.md b/src/ground/ride_comfort_transmissibility/README.md new file mode 100644 index 0000000000..745e1475aa --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/README.md @@ -0,0 +1,159 @@ +# ride_comfort_transmissibility:乘坐舒适性传递率 + +路面是一段段不同频率的起伏。车过某段搓板路时抖得厉害、换个车速又平稳了, +原因是悬架对不同频率的输入放大倍数不一样 —— 这就是**传递率**。 +这个模块把它算清楚:共振在哪个频率、放大多少倍、按 ISO 2631-1 属于哪个舒适度等级。 + +不依赖 CARLA、不需要显示器,纯 Python 标准库,Python 2.7 / 3.x 都能跑。 + +## 模型 + +单自由度基础激励(只看垂直方向): + +``` +r = f / f_n 频率比 +T(r) = sqrt((1 + (2ζr)²) / ((1 − r²)² + (2ζr)²)) 位移传递率 + +峰值位置 r_p = sqrt(1 − 2ζ²) (ζ ≥ 1/√2 时没有经典共振峰) +峰值大小 T_p = sqrt((1 + 4ζ²(1−2ζ²)) / (4ζ²(1−ζ²))) +高频衰减 T(r) → 0,r = 10 时约 0.05 +加权加速度 a_w = T(r) · a_in +``` + +ISO 2631-1 的舒适度等级(`a_w` 单位 m/s²,RMS): + +| a_w | 等级 | +|---|---| +| < 0.315 | 舒适 | +| 0.315 ~ 0.63 | 略有不适 | +| 0.63 ~ 1.0 | 不适 | +| 1.0 ~ 1.6 | 很不适 | +| 1.6 ~ 2.5 | 极不适 | +| > 2.5 | 无法忍受 | + +`damping` 被限制在 `(0, 1/√2)`:超过 0.7071 之后 `sqrt(1−2ζ²)` 没有实数意义, +闭式峰位失效,程序直接报 `RideError`,而不是给一个错的数。 + +## 默认数字(`config/ride_comfort_transmissibility.yaml`) + +| 项 | 值 | +|---|---| +| 悬架固有频率 / 阻尼比 | 1.2 Hz / 0.25 | +| 路面输入 / 激励频率 | 0.5 m/s² / 6.0 Hz | +| 理论峰位 / 峰值 | **0.935414 / 2.280351** | +| 扫描峰位 / 峰值 | 0.948625 / 2.283149(与闭式差 0.12%) | +| r = 1 处传递率 | 2.236068 | +| r = 10 处传递率 | 0.051440 | +| 6 Hz 处加权加速度 | 0.055794 m/s² → 等级「舒适」 | + +扫描表(10 个频率比): + +| r | f Hz | T | a_w m/s² | +|---|---|---|---| +| 0.25 | 0.30 | 1.0655 | 0.5328 | +| 0.50 | 0.60 | 1.3038 | 0.6519 | +| 0.75 | 0.90 | 1.8535 | 0.9267 | +| 1.00 | 1.20 | 2.2361 | 1.1180 | +| 1.25 | 1.50 | 1.4024 | 0.7012 | +| 1.50 | 1.80 | 0.8575 | 0.4287 | +| 2.00 | 2.40 | 0.4472 | 0.2236 | +| 3.00 | 3.60 | 0.2215 | 0.1107 | +| 5.00 | 6.00 | 0.1116 | 0.0558 | +| 10.00 | 12.00 | 0.0514 | 0.0257 | + +注意 r = 1(激励频率等于固有频率)时 T 是 2.236,但**真正的峰值 2.283 出现在 +r ≈ 0.949**,略低于共振比 —— 阻尼越大,峰位越往左偏。这是很多人会算错的地方。 + +## 四条断言 + +| 断言 | 判据 | 默认结果 | +|---|---|---| +| 共振位置 | 扫描峰位与 `sqrt(1−2ζ²)` 的偏差 ≤ 0.02 | PASS(0.0132) | +| 峰值倍率 | 扫描峰值与闭式峰值的相对偏差 ≤ 5% | PASS(0.12%) | +| 高频衰减 | `T(r=10) ≤ 0.1` | PASS(0.0514) | +| 输入线性 | 输入加倍后 `a_w` 精确加倍 | PASS(0.0000) | + +## 参数 + +| 参数 | 默认 | 说明 | +|---|---|---| +| `/suspension/fn_hz` | 1.2 | 悬架固有频率 Hz | +| `/suspension/damping` | 0.25 | 阻尼比,必须在 (0, 0.7071) 开区间 | +| `/road/input_accel` | 0.5 | 路面输入加速度 RMS m/s² | +| `/road/freq_hz` | 6.0 | 关心的激励频率 Hz | +| `/check/pos_tolerance` | 0.02 | 峰位容差(频率比) | +| `/check/peak_tolerance` | 0.05 | 峰值相对容差 | +| `/check/high_freq_limit` | 0.1 | r=10 时传递率上限 | +| `/check/linear_tolerance` | 0.02 | 输入加倍的线性容差 | +| `/scan/low` `/scan/high` `/scan/steps` | 0.05 / 4.0 / 400 | 扫描区间与步数 | +| `/rate/publish_hz` | 1.0 | 保活重发频率 Hz | + +## 话题 + +| 话题 | 类型 | 内容 | +|---|---|---| +| `/ride/report` | `std_msgs/String` | 整份报告 | +| `/ride/curve` | `std_msgs/Float64MultiArray` | 每个频率比三元组 `[r, T, a_w]`,共 30 个数 | +| `/ride/peak` | `std_msgs/Float64MultiArray` | `[理论峰位, 理论峰值, 扫描峰位, 扫描峰值, 激励处 a_w]` | + +三条都是 latched。 + +## 跑起来 + +```bash +cd ~/catkin_ws19 && catkin_make +source /opt/ros/melodic/setup.bash +source ~/catkin_ws19/devel/setup.bash +roslaunch ride_comfort_transmissibility main.launch +``` + +默认 `结论:PASSED`。两个有意思的反例: + +```bash +# ① 容差收到 0.001 → 扫描精度不够,只翻「共振位置」 +roslaunch ride_comfort_transmissibility main.launch pos_tolerance:=0.001 + +# ② 阻尼降到 0.02(坏减振器)→ 峰值 25 倍,激励频率挪到 1.2 Hz 就「无法忍受」 +roslaunch ride_comfort_transmissibility main.launch damping:=0.02 freq_hz:=1.2 +``` + +反例②很说明问题:四条断言**全部通过**(物理上它自洽),但舒适等级从「舒适」 +变成「无法忍受」。断言管的是「算得对不对」,等级管的是「人坐着难受不难受」。 + +## 离线测试 + +```bash +python3 tests/test_ride_comfort_transmissibility_local.py +``` + +覆盖 A 传递率基本形、B 闭式峰位峰值、C 舒适等级、D 四条断言、E 扫描表、 +F 字符图、G 参数读取、H 报告排版、I 闭式核对、J 工程文件约定、K 编码声明回归。 + +## 与已有模块的分工 + +| 模块 | 关注点 | 本模块的区别 | +|---|---|---| +| `rollover_margin` | 侧翻(横向载荷转移) | 管横向极限,本模块管垂直舒适性 | +| `lateral_stability_margin` | 不足转向/甩尾 | 管转向响应 | +| `braking_distance_check` | 纵向停车距离 | 管纵向制动 | +| `steering_actuator_lag` | 执行器一阶惯性 | 同是「频率响应」,但那是转向机构,本模块是悬架 | + +## 常见问题 + +**1. 为什么峰值不在 r = 1?** +`T(1) = sqrt(1+(2ζ)²)/(2ζ)`,而真正的极值点在 `r = sqrt(1−2ζ²)`。ζ = 0.25 时 +r_p = 0.935,峰值比 T(1) 高约 2%。阻尼越大偏得越多,这也是判据要写「峰位」 +而不是直接拿 r=1 当峰的原因。 + +**2. `damping:=0.8` 为什么直接报错?** +超过 `1/√2 ≈ 0.7071` 以后曲线没有经典共振峰,`sqrt(1−2ζ²)` 是虚数。与其给一个 +错的峰位,不如判参数非法 —— 现实里的悬架阻尼比也不会到 0.8。 + +**3. 高通/低通行为怎么读?** +`r → 0` 时 `T → 1`(车身跟着路面一起动,等于没有悬架);`r → ∞` 时 +`T → 0`(悬架把高频震动滤掉了)。所以舒适性设计的目标是把共振峰挪到人最不敏感 +的低频、同时把峰压下去,也就是「加大阻尼」。 + +## 大模型声明 + +本模块的代码编写、测试编写与文档整理使用了 AI 编程助手辅助,提交内容由本人负责。 diff --git a/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml b/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml new file mode 100644 index 0000000000..74b2b6e34f --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml @@ -0,0 +1,21 @@ +# ride_comfort_transmissibility 的默认参数 +# 由 launch/main.launch 载入 + +suspension: + fn_hz: 1.2 # 悬架固有频率 Hz + damping: 0.25 # 阻尼比(必须在 (0, 0.7071) 开区间) + +road: + input_accel: 0.5 # 路面输入加速度 RMS m/s^2 + freq_hz: 6.0 # 关心的路面激励频率 Hz + +check: + pos_tolerance: 0.02 # 峰位容差(频率比) + peak_tolerance: 0.05 # 峰值相对容差 + high_freq_limit: 0.1 # r=10 时传递率上限 + linear_tolerance: 0.02 # 输入加倍的线性容差 + +scan: + low: 0.05 # 扫描下限(频率比) + high: 4.0 # 扫描上限 + steps: 400 # 扫描步数 diff --git a/src/ground/ride_comfort_transmissibility/launch/main.launch b/src/ground/ride_comfort_transmissibility/launch/main.launch new file mode 100644 index 0000000000..7c1a0c919b --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/launch/main.launch @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/ground/ride_comfort_transmissibility/package.xml b/src/ground/ride_comfort_transmissibility/package.xml new file mode 100644 index 0000000000..956c943719 --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/package.xml @@ -0,0 +1,18 @@ + + + ride_comfort_transmissibility + 1.0.0 + + 乘坐舒适性传递率核算:单自由度悬架在路面正弦激励下的位移传递率、 + 共振峰位置与峰值倍率、ISO 2631-1 舒适度等级,并给出四条断言。 + 纯标准库实现,不依赖 CARLA、不需要显示器。 + + + Wist-sutton + MIT + + catkin + + rospy + std_msgs + diff --git a/src/ground/ride_comfort_transmissibility/scripts/main.py b/src/ground/ride_comfort_transmissibility/scripts/main.py new file mode 100644 index 0000000000..946bc28d26 --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/scripts/main.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""ride_comfort_transmissibility 节点入口:参数、核算、打印、发布。""" + +from __future__ import division, print_function, unicode_literals + +import os +import sys + +_HERE = os.path.dirname(os.path.abspath(__file__)) +if _HERE not in sys.path: + sys.path.insert(0, _HERE) + +from ride_node import main # noqa: E402 + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/ground/ride_comfort_transmissibility/scripts/ride_core.py b/src/ground/ride_comfort_transmissibility/scripts/ride_core.py new file mode 100644 index 0000000000..453b387a25 --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/scripts/ride_core.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""乘坐舒适性传递率核算(纯标准库,不依赖 ROS / CARLA / numpy)。 + +问题:车在某个频率的路面激励下,座椅/车身会被放大多少倍? +共振峰在哪里、有多高?按 ISO 2631 加权后属于哪个舒适度等级? + +模型(单自由度基础激励,位移传递率): + + r = f / f_n 频率比 + T(r) = sqrt((1 + (2ζr)²) / + ((1 − r²)² + (2ζr)²)) 传递率(放大倍数) + +三条闭式结论,正好用来写断言: + + 峰值位置 r_p = sqrt(1 − 2ζ²) (ζ ≥ 1/√2 时没有峰,T ≡ 1) + 峰值大小 T_p = 1 / (2ζ·sqrt(1 − ζ²)) + 高频衰减 T(r) → 0(r 越大越快趋近,r=10 时约 1/r² 量级) + +ISO 2631-1 的舒适度等级按加权加速度 a_w(m/s²,RMS)划分: + + < 0.315 舒适 + 0.315 ~ 0.63 略有不适 + 0.63 ~ 1.0 不适 + 1.0 ~ 1.6 很不适 + 1.6 ~ 2.5 极不适 + > 2.5 无法忍受 +""" + +from __future__ import division, print_function, unicode_literals + +import math + +ASSERT_NAMES = (u"共振位置", u"峰值倍率", u"高频衰减", u"输入线性") + +# (上限, 等级名),从低到高排列 +COMFORT_SCALE = ( + (0.315, u"舒适"), + (0.63, u"略有不适"), + (1.0, u"不适"), + (1.6, u"很不适"), + (2.5, u"极不适"), +) + + +class RideError(ValueError): + """参数非法。""" + + +def _positive(name, value): + if value is None or value <= 0: + raise RideError(u"%s 必须大于 0,收到 %r" % (name, value)) + return value + + +class RideSpec(object): + """悬架与激励参数。""" + + def __init__(self, fn_hz=1.2, damping=0.25, input_accel=0.5, + road_freq_hz=6.0): + self.fn_hz = _positive(u"固有频率", fn_hz) + # 上限取 1/sqrt(2)≈0.707:超过它传递率曲线不再有经典共振峰, + # 闭式峰位 sqrt(1-2ζ²) 也失去意义,索性判为参数非法。 + if damping <= 0 or damping >= 1.0 / math.sqrt(2.0): + raise RideError(u"阻尼比必须在 (0, 1/sqrt(2)) 开区间,收到 %r" + % (damping,)) + self.damping = damping + self.input_accel = _positive(u"输入加速度", input_accel) + self.road_freq_hz = _positive(u"路面激励频率", road_freq_hz) + + # ---- 传递率三件套 ---- + def ratio(self, freq_hz): + return freq_hz / self.fn_hz + + def transmissibility(self, freq_hz): + r = self.ratio(freq_hz) + zeta = self.damping + num = 1.0 + (2.0 * zeta * r) ** 2 + den = (1.0 - r * r) ** 2 + (2.0 * zeta * r) ** 2 + return math.sqrt(num / den) + + def transmissibility_at_ratio(self, r): + return self.transmissibility(r * self.fn_hz) + + def peak_ratio(self): + return math.sqrt(1.0 - 2.0 * self.damping ** 2) + + def peak_value(self): + """在 r_p = sqrt(1 − 2ζ²) 处取传递率,得到真实的峰值(ζ ≥ 1/√2 时为 1)。""" + zeta = self.damping + r2 = 1.0 - 2.0 * zeta ** 2 + w2 = 4.0 * zeta ** 2 + num = 1.0 + w2 * r2 + den = w2 * (1.0 - zeta ** 2) + return math.sqrt(num / den) + + def weighted_accel(self, freq_hz): + return self.transmissibility(freq_hz) * self.input_accel + + def __repr__(self): + return ("RideSpec(fn_hz=%.3f, damping=%.3f, input_accel=%.3f)" + % (self.fn_hz, self.damping, self.input_accel)) + + +def comfort_grade(aw): + """把加权加速度(m/s²)换成 ISO 2631 的等级名。""" + if aw < 0: + raise RideError(u"加权加速度不能为负,收到 %r" % (aw,)) + for limit, name in COMFORT_SCALE: + if aw < limit: + return name + return u"无法忍受" + + +def scan(spec, ratios): + """在给定频率比上取表:[(r, 频率, 传递率, 加权加速度), ...]。""" + rows = [] + for r in ratios: + if r <= 0: + raise RideError(u"频率比必须大于 0,收到 %r" % (r,)) + freq = r * spec.fn_hz + t = spec.transmissibility_at_ratio(r) + rows.append((r, freq, t, t * spec.input_accel)) + return rows + + +DEFAULT_RATIOS = (0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 5.0, 10.0) + + +def find_peak(spec, low=0.05, high=4.0, steps=400): + """在频率比区间上扫描,返回 (峰值频率比, 峰值传递率)。""" + if low <= 0 or high <= low or steps < 2: + raise RideError(u"扫描区间非法:low=%r high=%r steps=%r" + % (low, high, steps)) + best_r = low + best_t = spec.transmissibility_at_ratio(low) + for i in range(steps + 1): + r = low + (high - low) * i / steps + t = spec.transmissibility_at_ratio(r) + if t > best_t: + best_r, best_t = r, t + return best_r, best_t + + +def check_ride(spec, pos_tolerance=0.02, peak_tolerance=0.05, + high_freq_limit=0.1, linear_tolerance=0.02): + """四条断言:共振位置、峰值倍率、高频衰减、输入线性。""" + asserts = [] + + measured_r, measured_t = find_peak(spec) + theoretical_r = spec.peak_ratio() + pos_error = abs(measured_r - theoretical_r) + pos_detail = (u"扫描峰位 r=%.4f,理论 sqrt(1-2ζ²)=%.4f(偏差 %.4f,容差 %.3f)" + % (measured_r, theoretical_r, pos_error, pos_tolerance)) + pos_ok = pos_error <= pos_tolerance + 1e-12 + asserts.append({"type": ASSERT_NAMES[0], "passed": bool(pos_ok), + "detail": pos_detail}) + + theoretical_t = spec.peak_value() + rel = abs(measured_t - theoretical_t) / max(theoretical_t, 1e-12) + asserts.append({ + "type": ASSERT_NAMES[1], + "passed": bool(rel <= peak_tolerance + 1e-12), + "detail": (u"扫描峰值 %.4f,理论峰值 %.4f(相对偏差 %.4f,容差 %.2f)" + % (measured_t, theoretical_t, rel, peak_tolerance)), + }) + + far = spec.transmissibility_at_ratio(10.0) + asserts.append({ + "type": ASSERT_NAMES[2], + "passed": bool(far <= high_freq_limit + 1e-12), + "detail": (u"r=10 时传递率 %.6f,上限 %.3f(高频必须衰减)" + % (far, high_freq_limit)), + }) + + doubled = RideSpec(fn_hz=spec.fn_hz, damping=spec.damping, + input_accel=2.0 * spec.input_accel) + base = spec.weighted_accel(spec.road_freq_hz) + dbl = doubled.weighted_accel(spec.road_freq_hz) + rel_lin = abs(dbl - 2.0 * base) / max(2.0 * base, 1e-12) + asserts.append({ + "type": ASSERT_NAMES[3], + "passed": bool(rel_lin <= linear_tolerance + 1e-12), + "detail": (u"输入 %.2f → 加权 %.4f;输入加倍 → 加权 %.4f(相对偏差 %.4f)" + % (spec.input_accel, base, dbl, rel_lin)), + }) + return asserts + + +def render_transmissibility(spec, ratios=DEFAULT_RATIOS, width=40): + """按传递率画横向条形图(以峰值为满条)。""" + peak = spec.peak_value() + peak = peak if peak > 0 else 1.0 + lines = [u"传递率曲线(峰值 = 满条)", "-" * (width + 16)] + for r, freq, t, aw in scan(spec, ratios): + cells = int(round(t / peak * width)) + mark = u" <峰值" if abs(r - spec.peak_ratio()) < 0.13 else u"" + lines.append(u"r=%4.2f f=%5.2fHz |%s| T=%.3f%s" + % (r, freq, "#" * cells, t, mark)) + lines.append("-" * (width + 16)) + return "\n".join(lines) + + +def format_report(spec, asserts, ratios=DEFAULT_RATIOS): + """把参数、扫描表、断言与结论排成报告。""" + lines = [] + peak_r, peak_t = find_peak(spec) + lines.append(u"悬架:固有频率 %.3f Hz,阻尼比 %.3f,路面激励 %.2f Hz,输入 %.2f m/s²" + % (spec.fn_hz, spec.damping, spec.road_freq_hz, + spec.input_accel)) + lines.append(u"理论:峰位 r=%.4f,峰值 %.4f;ζ=%.3f" + % (spec.peak_ratio(), spec.peak_value(), spec.damping)) + lines.append(u"扫描:峰位 r=%.4f,峰值 %.4f" % (peak_r, peak_t)) + aw = spec.weighted_accel(spec.road_freq_hz) + lines.append(u"舒适性:加权加速度 %.3f m/s² → 等级「%s」" + % (aw, comfort_grade(aw))) + lines.append(u"频率比 频率(Hz) 传递率 加权(m/s²)") + for r, freq, t, a in scan(spec, ratios): + lines.append(u"%6.2f %8.3f %6.3f %8.3f" % (r, freq, t, a)) + lines.append(u"断言:%d 通过 / %d 失败(共 %d 条)" + % (len([a for a in asserts if a["passed"]]), + len([a for a in asserts if not a["passed"]]), len(asserts))) + for a in asserts: + lines.append(u" [%s] %s %s" % (u"PASS" if a["passed"] else u"FAIL", + a["type"], a["detail"])) + ok = all(a["passed"] for a in asserts) + lines.append(u"结论:%s" % (u"PASSED" if ok else u"FAILED")) + return "\n".join(lines) + + +class RideParams(object): + """把 /xxx/yyy 形式的参数名收成对象,缺省时用内置默认值。""" + + def __init__(self, **kwargs): + self.spec = RideSpec( + fn_hz=kwargs.get("suspension/fn_hz", 1.2), + damping=kwargs.get("suspension/damping", 0.25), + input_accel=kwargs.get("road/input_accel", 0.5), + road_freq_hz=kwargs.get("road/freq_hz", 6.0), + ) + self.pos_tolerance = kwargs.get("check/pos_tolerance", 0.02) + self.peak_tolerance = kwargs.get("check/peak_tolerance", 0.05) + self.high_freq_limit = kwargs.get("check/high_freq_limit", 0.1) + self.linear_tolerance = kwargs.get("check/linear_tolerance", 0.02) + self.scan_low = kwargs.get("scan/low", 0.05) + self.scan_high = kwargs.get("scan/high", 4.0) + self.scan_steps = int(kwargs.get("scan/steps", 400)) diff --git a/src/ground/ride_comfort_transmissibility/scripts/ride_node.py b/src/ground/ride_comfort_transmissibility/scripts/ride_node.py new file mode 100644 index 0000000000..a459e1837a --- /dev/null +++ b/src/ground/ride_comfort_transmissibility/scripts/ride_node.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""ride_comfort_transmissibility 的 ROS 节点。 + +发给 rospy 的日志必须是 byte str,统一走 _log()。 +""" + +from __future__ import division, print_function, unicode_literals + +import os +import sys + +_HERE = os.path.dirname(os.path.abspath(__file__)) +if _HERE not in sys.path: + sys.path.insert(0, _HERE) + +import ride_core as core # noqa: E402 + + +def _log(level, msg): + """把 unicode 消息转成 byte str 再交给 rospy。""" + import rospy + text = msg.encode("utf-8") if isinstance(msg, type(u"")) else msg + if level == "warn": + rospy.logwarn(text) + elif level == "err": + rospy.logerr(text) + else: + rospy.loginfo(text) + + +def main(argv=None): + import rospy + import std_msgs.msg as std_msg + + rospy.init_node("ride_comfort_transmissibility", anonymous=False) + + def par(name, default): + return rospy.get_param(name, default) + + params = core.RideParams( + **{ + "suspension/fn_hz": par("/suspension/fn_hz", 1.2), + "suspension/damping": par("/suspension/damping", 0.25), + "road/input_accel": par("/road/input_accel", 0.5), + "road/freq_hz": par("/road/freq_hz", 6.0), + "check/pos_tolerance": par("/check/pos_tolerance", 0.02), + "check/peak_tolerance": par("/check/peak_tolerance", 0.05), + "check/high_freq_limit": par("/check/high_freq_limit", 0.1), + "check/linear_tolerance": par("/check/linear_tolerance", 0.02), + "scan/low": par("/scan/low", 0.05), + "scan/high": par("/scan/high", 4.0), + "scan/steps": par("/scan/steps", 400), + } + ) + + spec = params.spec + peak_r, peak_t = core.find_peak(spec, params.scan_low, params.scan_high, + params.scan_steps) + asserts = core.check_ride( + spec, + pos_tolerance=params.pos_tolerance, + peak_tolerance=params.peak_tolerance, + high_freq_limit=params.high_freq_limit, + linear_tolerance=params.linear_tolerance, + ) + + report = core.format_report(spec, asserts) + _log("info", report) + _log("info", core.render_transmissibility(spec)) + + pub_report = rospy.Publisher("/ride/report", std_msg.String, + queue_size=1, latch=True) + pub_curve = rospy.Publisher("/ride/curve", std_msg.Float64MultiArray, + queue_size=1, latch=True) + pub_peak = rospy.Publisher("/ride/peak", std_msg.Float64MultiArray, + queue_size=1, latch=True) + + report_msg = std_msg.String() + report_msg.data = report + pub_report.publish(report_msg) + + curve_msg = std_msg.Float64MultiArray() + curve = [] + for r, freq, t, aw in core.scan(spec, core.DEFAULT_RATIOS): + curve.extend([r, t, aw]) + curve_msg.data = curve + pub_curve.publish(curve_msg) + + peak_msg = std_msg.Float64MultiArray() + peak_msg.data = [spec.peak_ratio(), spec.peak_value(), peak_r, peak_t, + spec.weighted_accel(spec.road_freq_hz)] + pub_peak.publish(peak_msg) + + passed = len([a for a in asserts if a["passed"]]) + _log("info", u"已发布 /ride/report、/ride/curve、/ride/peak" + u"(断言 %d/%d,激励处等级「%s」)" + % (passed, len(asserts), + core.comfort_grade(spec.weighted_accel(spec.road_freq_hz)))) + + rate = rospy.Rate(par("/rate/publish_hz", 1.0)) + while not rospy.is_shutdown(): + pub_report.publish(report_msg) + pub_curve.publish(curve_msg) + pub_peak.publish(peak_msg) + rate.sleep() + return 0 + + +if __name__ == "__main__": + sys.exit(main()) From 1657355fdde1427b2110b3fdadab22cab528f9ca Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:38:20 +0800 Subject: [PATCH 2/4] Add files via upload --- ...est_ride_comfort_transmissibility_local.py | 372 ++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 tests/test_ride_comfort_transmissibility_local.py diff --git a/tests/test_ride_comfort_transmissibility_local.py b/tests/test_ride_comfort_transmissibility_local.py new file mode 100644 index 0000000000..9eac9d646c --- /dev/null +++ b/tests/test_ride_comfort_transmissibility_local.py @@ -0,0 +1,372 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""ride_comfort_transmissibility 模块的离线回归测试。 + +特点: +* 只用 Python 标准库,**不需要 ROS、不需要 CARLA、不需要显示器** +* 同时兼容 Python 2.7 与 Python 3.x +* 在仓库根目录执行:python3 tests/test_ride_comfort_transmissibility_local.py + +覆盖范围: +A 传递率基本形 B 闭式峰位峰值 C 舒适等级 D 四条断言 +E 扫描表 F 字符图 G 参数读取 H 报告排版 +I 闭式核对 J 工程文件约定 K 编码声明回归 +""" + +from __future__ import division, print_function, unicode_literals + +import io +import math +import os +import sys + +try: # Python 2 兼容 + text_type = unicode # noqa: F821 +except NameError: + text_type = str + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) + +PKG = os.path.join(ROOT, "src", "ground", "ride_comfort_transmissibility") +SCRIPTS = os.path.join(PKG, "scripts") + +if SCRIPTS not in sys.path: + sys.path.insert(0, SCRIPTS) + +import ride_core as core # noqa: E402 + +FAILS = [] +OK = [0] + + +def out(text): + if isinstance(text, text_type): + sys.stdout.write(text + u"\n") + else: + sys.stdout.write(text + "\n") + + +def check(name, cond, detail=""): + OK[0] += 1 + if cond: + out(u" ok %s" % name) + else: + out(u" FAIL %s %s" % (name, detail)) + FAILS.append(name) + + +def near(a, b, tol=1e-9): + return abs(a - b) <= tol + + +def raises(exc, func, *args, **kwargs): + try: + func(*args, **kwargs) + except exc: + return True + except Exception: + return False + return False + + +# ------------------------------------------------------------ A 传递率基本形 +def group_shape(): + out(u"A 传递率基本形") + spec = core.RideSpec() + check(u"A1 零频传递率为 1", + near(spec.transmissibility_at_ratio(1e-6), 1.0, 1e-6), + repr(spec.transmissibility_at_ratio(1e-6))) + check(u"A2 共振比处 T=2.236", near(spec.transmissibility_at_ratio(1.0), 2.236068, 1e-6)) + check(u"A3 半频比处 T=1.304", near(spec.transmissibility_at_ratio(0.5), 1.303840, 1e-6)) + check(u"A4 两倍频比处 T=0.447", near(spec.transmissibility_at_ratio(2.0), 0.447214, 1e-6)) + check(u"A5 十倍频比处 T=0.0514", near(spec.transmissibility_at_ratio(10.0), 0.051440, 1e-6)) + check(u"A6 峰前单调增", + spec.transmissibility_at_ratio(0.3) < spec.transmissibility_at_ratio(0.6) + < spec.transmissibility_at_ratio(0.9)) + check(u"A7 峰后单调减", + spec.transmissibility_at_ratio(1.2) > spec.transmissibility_at_ratio(1.8) + > spec.transmissibility_at_ratio(3.0)) + check(u"A8 峰值大于共振比处值", + spec.peak_value() > spec.transmissibility_at_ratio(1.0)) + check(u"A9 频率比可换算", near(spec.ratio(2.4), 2.0, 1e-12)) + check(u"A10 传递率恒为正", + all(spec.transmissibility_at_ratio(r) > 0 for r in core.DEFAULT_RATIOS)) + + +# ------------------------------------------------------------ B 闭式峰位峰值 +def group_peak(): + out(u"B 闭式峰位峰值") + spec = core.RideSpec() + check(u"B1 峰位闭式 sqrt(1-2ζ²)", + near(spec.peak_ratio(), math.sqrt(1 - 2 * 0.25 ** 2), 1e-12)) + check(u"B2 峰位数值", near(spec.peak_ratio(), 0.935414, 1e-6)) + check(u"B3 峰值数值", near(spec.peak_value(), 2.280351, 1e-6)) + peak_r, peak_t = core.find_peak(spec) + check(u"B4 扫描峰位", near(peak_r, 0.948625, 1e-6)) + check(u"B5 扫描峰值", near(peak_t, 2.283149, 1e-6)) + check(u"B6 扫描峰值与闭式相对偏差 < 1%", + abs(peak_t - spec.peak_value()) / spec.peak_value() < 0.01) + check(u"B7 扫描峰位与闭式偏差 < 容差", + abs(peak_r - spec.peak_ratio()) < 0.02) + check(u"B8 阻尼变大峰值变小", + core.RideSpec(damping=0.4).peak_value() < spec.peak_value()) + check(u"B9 阻尼变小峰值变大", + core.RideSpec(damping=0.1).peak_value() > spec.peak_value()) + check(u"B10 扫描区间非法被拒", + raises(core.RideError, core.find_peak, spec, 0.0, 1.0, 10)) + + +# ------------------------------------------------------------ C 舒适等级 +def group_grade(): + out(u"C 舒适等级") + check(u"C1 0.3 舒适", core.comfort_grade(0.3) == u"舒适", core.comfort_grade(0.3)) + check(u"C2 0.315 边界进下一档", + core.comfort_grade(0.315) == u"略有不适") + check(u"C3 0.5 略有不适", core.comfort_grade(0.5) == u"略有不适") + check(u"C4 0.8 不适", core.comfort_grade(0.8) == u"不适") + check(u"C5 1.2 很不适", core.comfort_grade(1.2) == u"很不适") + check(u"C6 2.0 极不适", core.comfort_grade(2.0) == u"极不适") + check(u"C7 3.0 无法忍受", core.comfort_grade(3.0) == u"无法忍受") + check(u"C8 负值被拒", raises(core.RideError, core.comfort_grade, -0.1)) + check(u"C9 等级单调", + core.comfort_grade(0.2) == u"舒适" + and core.comfort_grade(2.4) == u"极不适") + check(u"C10 默认工况等级", + core.comfort_grade(core.RideSpec().weighted_accel(6.0)) == u"舒适") + + +# ------------------------------------------------------------ D 四条断言 +def group_asserts(): + out(u"D 四条断言") + spec = core.RideSpec() + asserts = core.check_ride(spec) + check(u"D1 断言条数为 4", len(asserts) == 4, repr(len(asserts))) + check(u"D2 断言名齐全", + tuple(a["type"] for a in asserts) == core.ASSERT_NAMES, + repr([a["type"] for a in asserts])) + check(u"D3 默认全部通过", all(a["passed"] for a in asserts), + repr([a["type"] for a in asserts if not a["passed"]])) + check(u"D4 每条有 detail", + all(isinstance(a["detail"], (u"").__class__) and a["detail"] + for a in asserts)) + check(u"D5 共振位置 detail 含扫描值", u"0.9486" in asserts[0]["detail"]) + check(u"D6 峰值 detail 含闭式值", u"2.2804" in asserts[1]["detail"]) + check(u"D7 高频 detail 含 10 倍频", u"r=10" in asserts[2]["detail"]) + check(u"D8 线性 detail 含加倍", + u"加倍" in asserts[3]["detail"], asserts[3]["detail"]) + + tight = core.check_ride(spec, pos_tolerance=0.001) + flipped = [a["type"] for a in tight if not a["passed"]] + check(u"D9 收紧位置容差只翻共振位置", + flipped == [core.ASSERT_NAMES[0]], repr(flipped)) + + strict = core.check_ride(spec, high_freq_limit=0.001) + flipped = [a["type"] for a in strict if not a["passed"]] + check(u"D10 收紧高频上限只翻高频衰减", + flipped == [core.ASSERT_NAMES[2]], repr(flipped)) + + soft = core.check_ride(core.RideSpec(damping=0.02)) + check(u"D11 软阻尼下四条仍全过", all(a["passed"] for a in soft)) + + +# ------------------------------------------------------------ E 扫描表 +def group_scan(): + out(u"E 扫描表") + spec = core.RideSpec() + rows = core.scan(spec, core.DEFAULT_RATIOS) + check(u"E1 行数", len(rows) == 10, repr(len(rows))) + check(u"E2 首行频率比", near(rows[0][0], 0.25)) + check(u"E3 末行频率比", near(rows[-1][0], 10.0)) + check(u"E4 频率换算", near(rows[3][1], 1.2, 1e-12)) + check(u"E5 共振比行传递率", near(rows[3][2], 2.236068, 1e-6)) + check(u"E6 加权等于传递率乘输入", + all(near(r[3], r[2] * spec.input_accel, 1e-12) for r in rows)) + check(u"E7 峰值出现在 0.75~1.25 之间", + rows[2][2] < rows[3][2] and rows[4][2] < rows[3][2]) + check(u"E8 非法频率比被拒", + raises(core.RideError, core.scan, spec, (0.0,))) + check(u"E9 自定义频率比可用", + len(core.scan(spec, (1.0, 2.0, 3.0))) == 3) + + +# ------------------------------------------------------------ F 字符图 +def group_render(): + out(u"F 字符图") + art = core.render_transmissibility(core.RideSpec()) + lines = art.split("\n") + check(u"F1 有标题", u"传递率曲线" in lines[0], lines[0]) + check(u"F2 有分隔线", lines[1].startswith("-") and lines[-1].startswith("-")) + check(u"F3 数据行数 10", len(lines) == 13, repr(len(lines))) + check(u"F4 共振行有峰值标记", any(u"<峰值" in ln for ln in lines)) + bars = [ln.count("#") for ln in lines[2:-1]] + check(u"F5 条形最宽在峰值行", bars.index(max(bars)) == 3, repr(bars)) + check(u"F6 宽度可调", + max(ln.count("#") for ln in + core.render_transmissibility(core.RideSpec(), width=12).split("\n")) <= 12) + + +# ------------------------------------------------------------ G 参数读取 +def group_params(): + out(u"G 参数读取") + params = core.RideParams() + check(u"G1 默认固有频率", near(params.spec.fn_hz, 1.2)) + check(u"G2 默认阻尼比", near(params.spec.damping, 0.25)) + check(u"G3 默认输入", near(params.spec.input_accel, 0.5)) + check(u"G4 默认激励频率", near(params.spec.road_freq_hz, 6.0)) + check(u"G5 默认位置容差", near(params.pos_tolerance, 0.02)) + check(u"G6 默认峰值容差", near(params.peak_tolerance, 0.05)) + check(u"G7 默认高频上限", near(params.high_freq_limit, 0.1)) + check(u"G8 默认线性容差", near(params.linear_tolerance, 0.02)) + + custom = core.RideParams(**{ + "suspension/fn_hz": 1.6, + "suspension/damping": 0.3, + "road/input_accel": 0.8, + "check/high_freq_limit": 0.2, + }) + check(u"G9 固有频率可覆盖", near(custom.spec.fn_hz, 1.6)) + check(u"G10 阻尼可覆盖", near(custom.spec.damping, 0.3)) + check(u"G11 输入可覆盖", near(custom.spec.input_accel, 0.8)) + check(u"G12 阈值可覆盖", near(custom.high_freq_limit, 0.2)) + check(u"G13 未覆盖项保持默认", near(custom.spec.road_freq_hz, 6.0)) + check(u"G14 非法阻尼被拒", + raises(core.RideError, core.RideSpec, damping=0.0)) + check(u"G15 过大阻尼被拒", + raises(core.RideError, core.RideSpec, damping=0.75)) + check(u"G16 非法固有频率被拒", + raises(core.RideError, core.RideSpec, fn_hz=-1.0)) + + +# ------------------------------------------------------------ H 报告排版 +def group_report(): + out(u"H 报告排版") + spec = core.RideSpec() + asserts = core.check_ride(spec) + text = core.format_report(spec, asserts) + check(u"H1 含悬架行", u"悬架:固有频率 1.200 Hz" in text) + check(u"H2 含理论行", u"理论:峰位 r=0.9354,峰值 2.2804" in text) + check(u"H3 含扫描行", u"扫描:峰位 r=0.9486" in text) + check(u"H4 含舒适性行", u"等级「舒适」" in text) + check(u"H5 含断言汇总", u"断言:4 通过 / 0 失败(共 4 条)" in text) + check(u"H6 含结论 PASSED", u"结论:PASSED" in text) + check(u"H7 每条断言都出现", all(a["type"] in text for a in asserts)) + rows = [line for line in text.split(u"\n") + if line.strip().startswith((u"0.25", u"0.50", u"0.75", u"1.00", + u"1.25", u"1.50", u"2.00", u"3.00", + u"5.00", u"10.00"))] + check(u"H8 表格有 10 行数据", + len(rows) == 10 and u"10.00" in text and u"12.000" in text) + + bad = core.format_report(spec, core.check_ride(spec, pos_tolerance=0.001)) + check(u"H9 反例结论 FAILED", u"结论:FAILED" in bad) + check(u"H10 反例含 1 失败", u"断言:3 通过 / 1 失败" in bad) + + +# ------------------------------------------------------------ I 闭式核对 +def group_identity(): + out(u"I 闭式核对") + spec = core.RideSpec() + zeta = spec.damping + # r=1 处的解析值:sqrt(1+(2ζ)²)/(2ζ) + analytic = math.sqrt(1 + (2 * zeta) ** 2) / (2 * zeta) + check(u"I1 共振比处解析值", near(spec.transmissibility_at_ratio(1.0), analytic, 1e-12)) + # 峰位处解析值(与 peak_value 同源,但用另一条式子写) + r = spec.peak_ratio() + alt = math.sqrt((1 + (2 * zeta * r) ** 2) / + ((1 - r * r) ** 2 + (2 * zeta * r) ** 2)) + check(u"I2 峰值与峰位处取值一致", near(alt, spec.peak_value(), 1e-12)) + # 高频渐近:ζ 很小时 T(10) ≈ 1/(100−1) + tiny = core.RideSpec(damping=1e-4) + check(u"I3 高频渐近 1/(r²-1)", + near(tiny.transmissibility_at_ratio(10.0), 1.0 / 99.0, 2e-3), + repr(tiny.transmissibility_at_ratio(10.0))) + # 加权线性 + a1 = spec.weighted_accel(2.4) + a2 = core.RideSpec(input_accel=1.0).weighted_accel(2.4) + check(u"I4 输入加倍加权加倍", near(a2, 2 * a1, 1e-12)) + # 固有频率只改变频率轴,不改变传递率 + other = core.RideSpec(fn_hz=2.4) + check(u"I5 固有频率不改变传递率", + near(other.transmissibility(2.4), spec.transmissibility(1.2), 1e-12)) + check(u"I6 峰值与阻尼反相关", + core.RideSpec(damping=0.05).peak_value() + > core.RideSpec(damping=0.5).peak_value()) + + +# ------------------------------------------------------------ J 工程文件约定 +def group_files(): + out(u"J 工程文件约定") + for rel in ("CMakeLists.txt", "package.xml", "README.md", + "config/ride_comfort_transmissibility.yaml", "launch/main.launch", + "scripts/main.py", "scripts/ride_core.py", + "scripts/ride_node.py"): + check(u"J %s 存在" % rel, os.path.isfile(os.path.join(PKG, rel))) + + launch = io.open(os.path.join(PKG, "launch", "main.launch"), + encoding="utf-8").read() + check(u"J launch 有 rosparam load", u'= 12", launch.count("= 12, + repr(launch.count(" Date: Wed, 11 Nov 2026 19:38:39 +0800 Subject: [PATCH 3/4] Add files via upload --- docs/ground/ride_comfort_transmissibility.md | 197 +++++++++++++++++++ 1 file changed, 197 insertions(+) create mode 100644 docs/ground/ride_comfort_transmissibility.md diff --git a/docs/ground/ride_comfort_transmissibility.md b/docs/ground/ride_comfort_transmissibility.md new file mode 100644 index 0000000000..02fddfd12c --- /dev/null +++ b/docs/ground/ride_comfort_transmissibility.md @@ -0,0 +1,197 @@ +# 乘坐舒适性传递率 + +路面不是平的。同一辆车,40 km/h 过某段路很难受,60 km/h 反而平稳 —— 这不是错觉, +是**悬架对不同频率的输入放大倍数不同**。把这件事算清楚,就是本模块要讲的传递率。 + +这个模块用纯标准库实现一个单自由度悬架模型,给出共振在哪个频率、放大多少倍、 +按 ISO 2631-1 属于哪个舒适度等级,并用四条断言把「算得对不对」钉住。 +不需要 CARLA、不需要显示器、不需要 numpy,Ubuntu 18.04 + ROS Melodic 直接可跑。 + +## 一、为什么需要这个包 + +仓库里 `src/ground/` 下的地面载具模块,纵向有 `braking_distance_check`、横向有 +`rollover_margin` 与 `lateral_stability_margin`,**垂直方向是空白**: + +| 方向 | 已有模块 | 管什么 | +|---|---|---| +| 纵向 | `braking_distance_check` | 反应距离 + 制动距离 | +| 横向(侧翻) | `rollover_margin` | 载荷转移与临界车速 | +| 横向(转向) | `lateral_stability_margin` | 不足转向梯度与特征车速 | +| 执行器 | `steering_actuator_lag` | 转向机构的一阶滞后 | +| **垂直** | **本模块** | **悬架传递率、共振、舒适度等级** | + +一条真实的工程链条是:悬架把路面震动放大到人体 → 人难受 → 驾驶员反应变慢 → +制动距离变长。前面三个模块都假设「驾驶员状态正常」,本模块补上这个前提被破坏时的量化依据。 + +## 二、模型 + +单自由度基础激励(只看垂直方向,忽略俯仰与侧倾耦合): + +``` +r = f / f_n 频率比(激励频率 / 固有频率) +T(r) = sqrt((1 + (2ζr)²) / ((1 − r²)² + (2ζr)²)) 位移传递率 +a_w = T(r) · a_in 加权加速度 RMS +``` + +三个解析结论: + +``` +峰值位置 r_p = sqrt(1 − 2ζ²) +峰值大小 T_p = sqrt((1 + 4ζ²(1−2ζ²)) / (4ζ²(1−ζ²))) +低频/高频 T(0) = 1;T(∞) = 0 +``` + +**峰值不在 r = 1**。r = 1 处 `T = sqrt(1+(2ζ)²)/(2ζ)`,ζ = 0.25 时是 2.236; +真正的极值在 r_p = 0.935,峰值 2.280,高出约 2%。阻尼越大偏得越多。 + +`damping` 被限制在 `(0, 1/√2)`:超过 0.7071 后 `sqrt(1−2ζ²)` 无实数意义,闭式峰位失效, +程序直接抛 `RideError`,而不是给一个错的数。现实里的悬架阻尼比也不会到 0.8。 + +舒适度等级(ISO 2631-1,`a_w` 单位 m/s² RMS): + +| a_w 区间 | 等级 | +|---|---| +| < 0.315 | 舒适 | +| 0.315 ~ 0.63 | 略有不适 | +| 0.63 ~ 1.0 | 不适 | +| 1.0 ~ 1.6 | 很不适 | +| 1.6 ~ 2.5 | 极不适 | +| > 2.5 | 无法忍受 | + +## 三、四条断言 + +| 断言 | 判据 | 默认实测 | 结果 | +|---|---|---|---| +| 共振位置 | 扫描峰位与 `sqrt(1−2ζ²)` 的偏差 ≤ 0.02 | 偏差 0.0132 | PASS | +| 峰值倍率 | 扫描峰值与闭式峰值的相对偏差 ≤ 5% | 偏差 0.0012(0.12%) | PASS | +| 高频衰减 | `T(r=10) ≤ 0.1` | 0.051440 | PASS | +| 输入线性 | 输入加倍后 `a_w` 精确加倍 | 相对偏差 0.0000 | PASS | + +四条互相独立:位置管「峰在哪」、倍率管「峰多高」、衰减管「隔振行不行」、 +线性管「叠加原理成不成立」。任何一条失败都能定位到具体环节。 + +## 四、默认数字 + +参数:`fn_hz = 1.2`、`damping = 0.25`、`input_accel = 0.5`、`freq_hz = 6.0` + +| 项 | 值 | +|---|---| +| 理论峰位 / 峰值 | **0.935414 / 2.280351** | +| 扫描峰位 / 峰值 | 0.948625 / 2.283149 | +| r = 1 处传递率 | 2.236068 | +| r = 10 处传递率 | 0.051440 | +| 6 Hz 处加权加速度 | 0.055794 m/s² → 等级「舒适」 | + +扫描表(10 个频率比,报告里原样打印): + +| r | f Hz | T | a_w m/s² | +|---|---|---|---| +| 0.25 | 0.300 | 1.066 | 0.533 | +| 0.50 | 0.600 | 1.304 | 0.652 | +| 0.75 | 0.900 | 1.853 | 0.927 | +| 1.00 | 1.200 | 2.236 | 1.118 | +| 1.25 | 1.500 | 1.402 | 0.701 | +| 1.50 | 1.800 | 0.857 | 0.429 | +| 2.00 | 2.400 | 0.447 | 0.224 | +| 3.00 | 3.600 | 0.221 | 0.111 | +| 5.00 | 6.000 | 0.112 | 0.056 | +| 10.00 | 12.000 | 0.051 | 0.026 | + +`r ≤ 1.5` 时 T > 1(放大),`r ≥ 2` 后迅速掉下来(隔振)。这就是过减速带要慢、 +跑高速反而稳的物理原因。 + +## 五、参数 + +| 参数 | 默认 | 说明 | +|---|---|---| +| `/suspension/fn_hz` | 1.2 | 悬架固有频率 Hz | +| `/suspension/damping` | 0.25 | 阻尼比,必须在 (0, 0.7071) 开区间 | +| `/road/input_accel` | 0.5 | 路面输入加速度 RMS m/s² | +| `/road/freq_hz` | 6.0 | 关心的激励频率 Hz | +| `/check/pos_tolerance` | 0.02 | 峰位容差(频率比) | +| `/check/peak_tolerance` | 0.05 | 峰值相对容差 | +| `/check/high_freq_limit` | 0.1 | r=10 时传递率上限 | +| `/check/linear_tolerance` | 0.02 | 输入加倍的线性容差 | +| `/scan/low` `/scan/high` `/scan/steps` | 0.05 / 4.0 / 400 | 扫描区间与步数 | +| `/rate/publish_hz` | 1.0 | 保活重发频率 Hz | + +## 六、话题 + +| 话题 | 类型 | 内容 | +|---|---|---| +| `/ride/report` | `std_msgs/String` | 整份报告(含断言与结论) | +| `/ride/curve` | `std_msgs/Float64MultiArray` | 每个频率比三元组 `[r, T, a_w]`,共 30 个数 | +| `/ride/peak` | `std_msgs/Float64MultiArray` | `[理论峰位, 理论峰值, 扫描峰位, 扫描峰值, 激励处 a_w]` | + +三条都 `latch=True`。 + +## 七、运行 + +```bash +mkdir -p ~/catkin_ws19/src/ground ~/catkin_ws19/tests ~/catkin_ws19/docs/ground +# 把包放进来,改 shebang,catkin_make,source,roslaunch +roslaunch ride_comfort_transmissibility main.launch +``` + +默认输出 `结论:PASSED`。两个反例: + +```bash +# ① 容差收到 0.001:扫描精度不够,只翻「共振位置」 +roslaunch ride_comfort_transmissibility main.launch pos_tolerance:=0.001 + +# ② 阻尼 0.02(坏减振器)+ 激励挪到 1.2 Hz:峰值 25 倍,等级「无法忍受」 +roslaunch ride_comfort_transmissibility main.launch damping:=0.02 freq_hz:=1.2 +``` + +反例②值得多看一眼:四条断言**全部通过**(物理上它自洽),但舒适等级从「舒适」 +变成「无法忍受」。**断言管的是「算得对不对」,等级管的是「人坐着难受不难受」** —— +两者不能互相替代,这也是我特意把等级做成独立输出的原因。 + +## 八、离线测试 + +```bash +python3 tests/test_ride_comfort_transmissibility_local.py +``` + +**通过 112 项,失败 0 项**,覆盖: + +| 组 | 内容 | +|---|---| +| A | 传递率基本形(T(0)=1、T(1)、单调段) | +| B | 闭式峰位与峰值 | +| C | 舒适度等级分档 | +| D | 四条断言的正反例 | +| E | 扫描表数值与单调性 | +| F | 字符图排版 | +| G | 参数读取与非法值拒绝 | +| H | 报告排版(表头、行数、结论) | +| I | 闭式恒等式(r_p 处取 T 就是 T_p) | +| J | 三个脚本的工程约定(shebang、coding、保活) | +| K | 编码声明回归(防 `Non-ASCII character` 报错) | + +## 九、与已有模块的分工 + +前面第一节的表已经列了纵向/横向/执行器/垂直四块。补一句边界: +`steering_actuator_lag` 也是「频率响应」,但它是**转向机构**的一阶惯性; +本模块是**悬架**的二阶共振。两者都有「频率越高越跟不上」,但物理对象、微分方程阶数、 +关心的频段完全不同(转向 2~10 Hz,车身 1~2 Hz)。 + +## 十、常见问题 + +**1. 为什么峰值不在 r = 1?** +因为 r = 1 只是「分母实部为 0」的位置,不是传递率对 r 的极值点。 +`T(1) = sqrt(1+(2ζ)²)/(2ζ)`,极值点在 `r = sqrt(1−2ζ²)`,ζ = 0.25 时差 1.3%。 +判据里写「峰位」而不是直接拿 r = 1 当峰,就是为了不让这个偏差蒙混过去。 + +**2. 为什么 `damping:=0.8` 直接报错?** +超过 `1/√2 ≈ 0.7071` 后曲线没有经典共振峰,`sqrt(1−2ζ²)` 是虚数。 +与其返回一个错的峰位,不如判参数非法。测试 G15 就是查这个事情。 + +**3. 高通/低通行为怎么读?** +`r → 0` 时 `T → 1`(车身跟着路面一起动,等于没悬架);`r → ∞` 时 `T → 0` +(高频震动被滤掉)。所以舒适性设计的目标是:把共振峰挪到人最不敏感的低频、 +同时把峰压下去 —— 后者靠加阻尼,前者靠改固有频率(也就是改悬架刚度与簧上质量)。 + +## 十一、大模型使用声明 + +本模块的代码编写、测试编写与文档整理使用了 AI 编程助手辅助,提交内容由本人负责。 From 17c2b966db21d94e8fd60d8769244b9d17001e4f Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:41:05 +0800 Subject: [PATCH 4/4] Add ride comfort transmissibility section to index --- docs/index.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/index.md b/docs/index.md index fcfb8c3e75..2500b289b2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -228,6 +228,7 @@ ROS 2 服务与参数基础实验(无人机模式切换与在线调参):[c * [前视相机车道偏离预警(视觉横向偏移与地图真值对照)](./ground/carla_visual_lane_departure_warning.md) —— 用前视图像估计横向偏移,并与地图真值逐帧对照 * [差速 AGV 坡道起步辅助(防溜车)](./ground/hill_start_assist.md) —— MuJoCo 12° 斜坡,四轮轮角保持 PD + 坡度前馈,松刹车 3 s 后溜 2.18 m 降到 0.008 m * [地面移动底盘速度指令安全监督](./ground/cmd_vel_guard.md) —— 对 `/cmd_vel` 做限幅、急停、超时与非法值拦截,无需仿真环境 +* [乘坐舒适性传递率](./ground/ride_comfort_transmissibility.md) —— 二自由度悬架在路面激励下的传递率曲线、共振峰与加权加速度等级 ## 5. 空域载具