From 0d85be70aed5e864467d89e382d283a04e899093 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:32:06 +0800 Subject: [PATCH 1/6] Add files via upload --- src/ground/drive_cycle_energy/CMakeLists.txt | 18 + src/ground/drive_cycle_energy/README.md | 143 ++++++++ .../config/drive_cycle_energy.yaml | 23 ++ .../drive_cycle_energy/launch/main.launch | 35 ++ src/ground/drive_cycle_energy/package.xml | 16 + .../drive_cycle_energy/scripts/energy_core.py | 316 ++++++++++++++++++ .../drive_cycle_energy/scripts/energy_node.py | 110 ++++++ src/ground/drive_cycle_energy/scripts/main.py | 18 + 8 files changed, 679 insertions(+) create mode 100644 src/ground/drive_cycle_energy/CMakeLists.txt create mode 100644 src/ground/drive_cycle_energy/README.md create mode 100644 src/ground/drive_cycle_energy/config/drive_cycle_energy.yaml create mode 100644 src/ground/drive_cycle_energy/launch/main.launch create mode 100644 src/ground/drive_cycle_energy/package.xml create mode 100644 src/ground/drive_cycle_energy/scripts/energy_core.py create mode 100644 src/ground/drive_cycle_energy/scripts/energy_node.py create mode 100644 src/ground/drive_cycle_energy/scripts/main.py diff --git a/src/ground/drive_cycle_energy/CMakeLists.txt b/src/ground/drive_cycle_energy/CMakeLists.txt new file mode 100644 index 0000000000..59998ec679 --- /dev/null +++ b/src/ground/drive_cycle_energy/CMakeLists.txt @@ -0,0 +1,18 @@ +cmake_minimum_required(VERSION 3.0.2) +project(drive_cycle_energy) + +find_package(catkin REQUIRED) + +catkin_package() + +catkin_install_python(PROGRAMS + scripts/main.py + scripts/energy_core.py + scripts/energy_node.py + DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +) + +install(DIRECTORY launch config docs + DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} + USE_SOURCE_PERMISSIONS +) diff --git a/src/ground/drive_cycle_energy/README.md b/src/ground/drive_cycle_energy/README.md new file mode 100644 index 0000000000..cdbf1d7a4d --- /dev/null +++ b/src/ground/drive_cycle_energy/README.md @@ -0,0 +1,143 @@ +# drive_cycle_energy —— 工况能耗与续航核算 + +给定一段行驶工况(每段「时长 + 起始车速 + 结束车速」),把电池的能量花到哪里算清楚: +滚阻、风阻、制动损失、动能各占多少,再生制动能收回多少,满电能跑多远。 + +**纯标准库、纯计算**:不需要 CARLA、不需要 GPU、不需要显示器,`python3` 直接就能跑离线测试。 + +## 为什么做这个包 + +仓库里已有三个和「能耗」擦边的模块,但都不回答「这段工况电都花在哪了」: + +| 已有模块 | 它回答什么 | +|---|---| +| `speed_profile_check` | 一段距离内怎么分配加减速时间(运动学,不算阻力) | +| `braking_distance_check` | 从看见到停住要几米(只算制动段) | +| `lateral_stability_margin` | 转弯稳不稳(横向) | +| **本包** | **纵向能量流:滚阻 / 风阻 / 制动 / 动能的分配,以及续航** | + +关键点是**能量分解可以写成闭式恒等式**,于是「实现对不对」能被第四条断言直接卡住: + +``` +E_drive − E_brake = E_roll + E_aero + ΔKE +E_roll = m·g·c_rr · 行驶距离 (滚阻力与车速无关) +E_aero = 0.5·ρ·Cd·A · ∫v³ dt (风阻力与车速平方成正比) +ΔKE = 0.5·m·(v_end² − v_start²) +``` + +## 安装与运行 + +本包是 catkin 包,放进工作空间即可(不需要编译 C++): + +```bash +cd ~/catkin_ws18 +catkin_make +source /opt/ros/melodic/setup.bash +source devel/setup.bash +``` + +跑起来(参数全部在 `config/drive_cycle_energy.yaml`,命令行可覆盖): + +```bash +roslaunch drive_cycle_energy main.launch +roslaunch drive_cycle_energy main.launch regen_eff:=0.0 regen_limit:=0.5 +``` + +看发布出来的东西: + +```bash +rostopic echo -n 1 /energy/report # 文字报告(latched) +rostopic echo -n 1 /energy/breakdown # 逐项能量 CSV(latched) +rostopic echo -n 1 /energy/range # 满电续航 km(latched) +rosparam get /vehicle/battery_kwh # 确认参数生效 +``` + +## 参数(12 个) + +| 参数 | 默认 | 含义 | +|---|---|---| +| `vehicle/mass` | 1800.0 | 整备质量 kg | +| `vehicle/c_rr` | 0.012 | 滚动阻力系数 | +| `vehicle/cd` | 0.31 | 风阻系数 | +| `vehicle/area` | 2.2 | 迎风面积 m² | +| `vehicle/battery_kwh` | 60.0 | 电池可用容量 kWh | +| `vehicle/regen_eff` | 0.6 | 再生制动回收效率 0~1 | +| `check/breakdown_tolerance` | 0.02 | 能量分解相对偏差上限 | +| `check/regen_limit` | 1.0 | 回收 / 制动 的上限 | +| `rate/publish_hz` | 10.0 | 保活循环频率 | +| `topic/report` | `/energy/report` | 文字报告话题 | +| `topic/breakdown` | `/energy/breakdown` | 逐项能量 CSV | +| `topic/range` | `/energy/range` | 满电续航 km | + +## 话题(3 路,都是 latched) + +| 话题 | 类型 | 内容 | +|---|---|---| +| `/energy/report` | `std_msgs/String` | 完整报告(工况、能量、分解、续航、四条断言) | +| `/energy/breakdown` | `std_msgs/String` | `item,joules` 七行 CSV | +| `/energy/range` | `std_msgs/Float64` | 满电续航 km | + +## 默认工况与结果 + +默认工况 8 段共 60 s:0→30、30 匀速、30→50、50 匀速、50→0、怠速、0→40、40 匀速,行驶 512.5 m。 + +| 量 | 值 | +|---|---| +| 驱动能量 | **407.3 kJ** | +| 制动能量 | 159.6 kJ | +| 回收能量(η=0.6) | **95.8 kJ** | +| 净耗 | **311.5 kJ** | +| 分解 | 滚阻 108.6 kJ(26.7%)/ 风阻 28.0 kJ(6.9%)/ 制动 159.6 kJ(39.2%)/ 动能 111.1 kJ(27.3%)| +| 百公里电耗 | **16.89 kWh** | +| 满电续航 | **355.3 km** | + +四条断言全过: + +``` +[PASS] 能量分解 滚阻 108.6 + 风阻 28.0 + 制动 159.6 + 动能 111.1 = 407.3 kJ(偏差 0.0000) +[PASS] 回收上限 回收 95.8 / 制动 159.6 = 0.6000(上限 1.00,η=0.60) +[PASS] 续航自洽 百公里 16.885 kWh,电池 60.0 kWh → 续航 355.3 km +[PASS] 风阻上升 10 m/s 40.9 N < 30 m/s 368.3 N +``` + +## 两个反例 + +1. `regen_limit:=0.5` → **只翻「回收上限」**(0.6000 > 0.50),其余三条仍通过; +2. `regen_eff:=0.0` → 净耗从 311.5 kJ 涨到 **407.3 kJ**、续航从 355.3 km 掉到 **271.8 km**, + 四条断言依然全过 —— 说明断言校验的是「自洽」,不是「车好不好」; + 要看回收有没有收益,得对比这两次运行。 + +## 离线测试 + +```bash +python3 tests/test_drive_cycle_energy_local.py +``` + +**通过 152 项,失败 0 项**,覆盖:参数校验、阻力计算、工况解析、积分、四条断言、 +能量恒等式、续航与百公里、字符图、报告文本、参数对象、工程文件约定。 + +其中 K 组专门回归本项目踩过的坑:逐个文件检查 `scripts/*.py` 的 +**第 1 行是 shebang、第 2 行是 `# -*- coding: utf-8 -*-`**。 +Melodic 的 Python 2.7 要求编码声明在前两行,而 `sed` 改 shebang 时若整行覆盖, +编码声明就会丢,节点一启动就 `SyntaxError: Non-ASCII character ... no encoding declared`。 + +## 与其他模块的分工 + +- `speed_profile_check`:只算运动学(距离、时间、加减速),不含阻力; +- 本包:在运动学之上加阻力模型与电池模型,算能量与续航; +- `braking_distance_check`:只关心「停得住吗」,不含回收; +- `lateral_stability_margin`:横向稳定性,与本包的纵向能量互不重叠。 + +## 常见问题 + +**Q:`rostopic echo` 一直卡着不动?** +latched 话题会一直重发最后一条;加 `-n 1` 只取一条。 + +**Q:数字和 README 对不上?** +先 `rosparam get /vehicle/mass` 等确认没被命令行或其它 yaml 覆盖。 + +**Q:能换成自己的工况吗?** +改 `energy_core.DEFAULT_CYCLE`(每段 `(时长, 起始 km/h, 结束 km/h)`),或在代码里 +`core.simulate(spec, 你自己的段列表)`。 + +> 所使用具体的大模型声明:使用大模型辅助代码编写、测试编写与文档整理,提交内容由本人负责。 diff --git a/src/ground/drive_cycle_energy/config/drive_cycle_energy.yaml b/src/ground/drive_cycle_energy/config/drive_cycle_energy.yaml new file mode 100644 index 0000000000..12196d1210 --- /dev/null +++ b/src/ground/drive_cycle_energy/config/drive_cycle_energy.yaml @@ -0,0 +1,23 @@ +# drive_cycle_energy default parameters +# loaded by launch/main.launch via +# roslaunch arg xxx:=yyy overrides these values. +# NOTE: keep this file pure ASCII -- ROS Melodic (Python 2.7) loads it with +# an ASCII codec and fails on non-ASCII comments. + +# ---- vehicle and battery ---- +vehicle/mass: 1800.0 +vehicle/c_rr: 0.012 +vehicle/cd: 0.31 +vehicle/area: 2.2 +vehicle/battery_kwh: 60.0 +vehicle/regen_eff: 0.6 + +# ---- assertion tolerances ---- +check/breakdown_tolerance: 0.02 +check/regen_limit: 1.0 + +# ---- publishing ---- +rate/publish_hz: 10.0 +topic/report: /energy/report +topic/breakdown: /energy/breakdown +topic/range: /energy/range diff --git a/src/ground/drive_cycle_energy/launch/main.launch b/src/ground/drive_cycle_energy/launch/main.launch new file mode 100644 index 0000000000..002c5892dc --- /dev/null +++ b/src/ground/drive_cycle_energy/launch/main.launch @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/ground/drive_cycle_energy/package.xml b/src/ground/drive_cycle_energy/package.xml new file mode 100644 index 0000000000..04a8a208da --- /dev/null +++ b/src/ground/drive_cycle_energy/package.xml @@ -0,0 +1,16 @@ + + + drive_cycle_energy + 1.0.0 + 工况能耗与续航核算:按纵向动力学把驱动能量分解为滚阻/风阻/制动/动能, + 并估算百公里电耗与满电续航;纯计算,不依赖 CARLA 与显示器。 + ncut + MIT + + catkin + + rospy + std_msgs + + + diff --git a/src/ground/drive_cycle_energy/scripts/energy_core.py b/src/ground/drive_cycle_energy/scripts/energy_core.py new file mode 100644 index 0000000000..6c431c0492 --- /dev/null +++ b/src/ground/drive_cycle_energy/scripts/energy_core.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""工况能耗与续航核算(纯标准库,不依赖 ROS / CARLA / numpy)。 + +问题:一段行驶工况里,电池到底把多少能量花在滚阻、风阻和加减速上? +再生制动能收回多少?满电能跑多远? + +模型(纵向动力学,纵向加速度 a,坡度忽略): + 驱动力 F = m·a + m·g·c_rr + 0.5·ρ·Cd·A·v² + 滚阻力 F_rr = m·g·c_rr (与车速无关) + 风阻力 F_aero = 0.5·ρ·Cd·A·v² (与车速平方成正比) + 回收 E_regen = η · ∫|F_brake|·v dt (只在减速时发生,η 是回收效率) + 续航 range = 电池容量 / 每公里净耗电 + +核心恒等式(正是第一条断言的依据): + E_drive − E_brake = E_roll + E_aero + ΔKE + ⇔ E_drive = E_roll + E_aero + E_brake + ΔKE +其中 ΔKE 是整段工况的动能净变化(起终点车速相同则为零)。 +滚阻与风阻都能写成速度的幂函数,因此这一分解可以逐项积出来再对账。 +""" + +from __future__ import division, print_function, unicode_literals + +ASSERT_NAMES = (u"能量分解", u"回收上限", u"续航自洽", u"风阻上升") + + +class EnergyError(ValueError): + """参数或工况非法。""" + + +def _positive(name, value): + if value is None or value <= 0: + raise EnergyError(u"%s 必须大于 0,收到 %r" % (name, value)) + return value + + +def _non_negative(name, value): + if value is None or value < 0: + raise EnergyError(u"%s 不能为负,收到 %r" % (name, value)) + return value + + +class VehicleSpec(object): + """整车与电池参数。""" + + def __init__(self, mass=1800.0, c_rr=0.012, rho=1.2, cd=0.31, area=2.2, + gravity=9.81, battery_kwh=60.0, regen_eff=0.6): + self.mass = _positive(u"质量", mass) + self.c_rr = _non_negative(u"滚阻系数", c_rr) + self.rho = _positive(u"空气密度", rho) + self.cd = _positive(u"风阻系数", cd) + self.area = _positive(u"迎风面积", area) + self.gravity = _positive(u"重力加速度", gravity) + self.battery_kwh = _positive(u"电池容量", battery_kwh) + if regen_eff < 0 or regen_eff > 1: + raise EnergyError(u"回收效率必须在 [0, 1],收到 %r" % (regen_eff,)) + self.regen_eff = regen_eff + + # ---- 阻力 ---- + def rolling_force(self): + return self.mass * self.gravity * self.c_rr + + def aero_force(self, speed): + return 0.5 * self.rho * self.cd * self.area * speed * speed + + def resistance(self, speed): + return self.rolling_force() + self.aero_force(speed) + + def traction_force(self, speed, accel): + return self.mass * accel + self.resistance(speed) + + def kinetic(self, speed): + return 0.5 * self.mass * speed * speed + + def battery_joules(self): + return self.battery_kwh * 3.6e6 + + def __repr__(self): + return ("VehicleSpec(mass=%.1f, c_rr=%.3f, cd=%.3f, area=%.2f, " + "battery_kwh=%.1f, regen_eff=%.2f)" + % (self.mass, self.c_rr, self.cd, self.area, + self.battery_kwh, self.regen_eff)) + + +def parse_segments(segments): + """把 [(秒, 起始 km/h, 结束 km/h), ...] 规整成 [(t, v0, v1), ...](m/s)。""" + out = [] + for i, seg in enumerate(segments): + if len(seg) != 3: + raise EnergyError(u"第 %d 段必须是 (秒, 起始, 结束),收到 %r" % (i, seg)) + hold, v0, v1 = seg + if hold <= 0: + raise EnergyError(u"第 %d 段时长必须大于 0,收到 %r" % (i, hold)) + if v0 < 0 or v1 < 0: + raise EnergyError(u"第 %d 段车速不能为负,收到 %r" % (i, seg)) + out.append((float(hold), float(v0) / 3.6, float(v1) / 3.6)) + if not out: + raise EnergyError(u"工况至少要有一段") + return out + + +def simulate(spec, segments, dt=0.05): + """按固定步长(中点法)积分一段工况,返回能量与统计量。""" + segs = parse_segments(segments) + if dt <= 0: + raise EnergyError(u"步长必须大于 0,收到 %r" % (dt,)) + + drive_j = 0.0 + brake_j = 0.0 + roll_j = 0.0 + aero_j = 0.0 + ke_j = 0.0 + distance = 0.0 + duration = 0.0 + v_max = 0.0 + + for hold, v0, v1 in segs: + accel = (v1 - v0) / hold + steps = int(round(hold / dt)) or 1 + step = hold / steps + for i in range(steps): + v = v0 + accel * (i + 0.5) * step + if v < 0: + v = 0.0 + force = spec.traction_force(v, accel) + work = force * v * step + if work >= 0: + drive_j += work + else: + brake_j += -work + roll_j += spec.rolling_force() * v * step + aero_j += spec.aero_force(v) * v * step + ke_j += spec.mass * accel * v * step + distance += v * step + v_max = max(v_max, v) + duration += hold + + regen_j = spec.regen_eff * brake_j + net_j = drive_j - regen_j + return { + "drive_j": drive_j, + "brake_j": brake_j, + "regen_j": regen_j, + "roll_j": roll_j, + "aero_j": aero_j, + "ke_j": ke_j, + "net_j": net_j, + "distance_m": distance, + "duration_s": duration, + "v_max": v_max, + } + + +def per_100km(result): + """每 100 km 净耗电(kWh)。""" + if result["distance_m"] <= 0: + raise EnergyError(u"工况没有行驶距离,无法折算百公里能耗") + return result["net_j"] / 3.6e6 / (result["distance_m"] / 100000.0) + + +def range_km(spec, result): + """满电续航(km)。""" + kwh_per_100 = per_100km(result) + if kwh_per_100 <= 0: + raise EnergyError(u"净耗电不为正,续航无意义") + return spec.battery_kwh / kwh_per_100 * 100.0 + + +def share(result, key): + """某一项能量占驱动能量的比例。""" + if result["drive_j"] <= 0: + raise EnergyError(u"驱动能量不为正,无法计算占比") + return result[key] / result["drive_j"] + + +def check_energy(spec, result, breakdown_tolerance=0.02, regen_limit=1.0, + range_tolerance=0.02, aero_rising=True): + """四条断言:分解自洽、回收上限、续航自洽、风阻随车速上升。""" + asserts = [] + + total = (result["roll_j"] + result["aero_j"] + result["brake_j"] + + result["ke_j"]) + if result["drive_j"] <= 0: + rel = 1.0 + else: + rel = abs(total - result["drive_j"]) / result["drive_j"] + asserts.append({ + "type": ASSERT_NAMES[0], + "passed": bool(rel <= breakdown_tolerance + 1e-12), + "detail": (u"滚阻 %.1f + 风阻 %.1f + 制动 %.1f + 动能 %.1f = %.1f kJ," + u"驱动 %.1f kJ(相对偏差 %.4f,容差 %.2f)" + % (result["roll_j"] / 1000.0, result["aero_j"] / 1000.0, + result["brake_j"] / 1000.0, result["ke_j"] / 1000.0, + total / 1000.0, result["drive_j"] / 1000.0, + rel, breakdown_tolerance)), + }) + + if result["brake_j"] <= 0: + ratio = 0.0 + else: + ratio = result["regen_j"] / result["brake_j"] + asserts.append({ + "type": ASSERT_NAMES[1], + "passed": bool(ratio <= regen_limit + 1e-12), + "detail": (u"回收 %.1f kJ / 制动 %.1f kJ = %.4f(上限 %.2f,η=%.2f)" + % (result["regen_j"] / 1000.0, result["brake_j"] / 1000.0, + ratio, regen_limit, spec.regen_eff)), + }) + + try: + kwh_per_100 = per_100km(result) + implied = spec.battery_kwh / kwh_per_100 * 100.0 + rel_range = abs(implied - range_km(spec, result)) / max(implied, 1e-9) + range_ok = rel_range <= range_tolerance + 1e-12 + range_detail = (u"百公里 %.3f kWh,电池 %.1f kWh → 续航 %.1f km(相对偏差 %.4f)" + % (kwh_per_100, spec.battery_kwh, implied, rel_range)) + except EnergyError as exc: + range_ok = False + range_detail = u"无法折算续航:%s" % (exc,) + asserts.append({ + "type": ASSERT_NAMES[2], + "passed": bool(range_ok), + "detail": range_detail, + }) + + aero_slow = spec.aero_force(10.0) + aero_fast = spec.aero_force(30.0) + rising = aero_fast > aero_slow + asserts.append({ + "type": ASSERT_NAMES[3], + "passed": bool(rising if aero_rising else (not rising)), + "detail": (u"10 m/s 风阻 %.1f N,30 m/s 风阻 %.1f N(期望%s)" + % (aero_slow, aero_fast, u"上升" if aero_rising else u"不上升")), + }) + return asserts + + +def render_energy(result, width=42): + """按比例画能量条。""" + rows = [ + (u"滚阻", result["roll_j"]), + (u"风阻", result["aero_j"]), + (u"制动", result["brake_j"]), + (u"动能", result["ke_j"]), + (u"驱动", result["drive_j"]), + (u"回收", result["regen_j"]), + ] + biggest = max([v for _, v in rows] + [1.0]) + lines = [u"能量构成(驱动 = 满条,其余按比例)", "-" * width] + for label, value in rows: + cells = int(round(max(value, 0.0) / biggest * width)) + lines.append(u"%s|%s| %8.1f kJ" % (label, "#" * cells, value / 1000.0)) + lines.append("-" * width) + return "\n".join(lines) + + +def format_report(spec, result, asserts): + """把上面的一切排成人能读的报告。""" + lines = [] + lines.append(u"工况:%.1f s,行驶 %.1f m,最高 %.1f km/h" + % (result["duration_s"], result["distance_m"], + result["v_max"] * 3.6)) + lines.append(u"整车:质量 %.0f kg,滚阻 %.3f,Cd·A %.2f m²,电池 %.1f kWh,回收 η %.2f" + % (spec.mass, spec.c_rr, spec.cd * spec.area, + spec.battery_kwh, spec.regen_eff)) + lines.append(u"能量:驱动 %.1f kJ,制动 %.1f kJ,回收 %.1f kJ,净耗 %.1f kJ" + % (result["drive_j"] / 1000.0, result["brake_j"] / 1000.0, + result["regen_j"] / 1000.0, result["net_j"] / 1000.0)) + lines.append(u"分解:滚阻 %.1f kJ(%.1f%%),风阻 %.1f kJ(%.1f%%)," + u"制动 %.1f kJ(%.1f%%),动能 %.1f kJ(%.1f%%)" + % (result["roll_j"] / 1000.0, share(result, "roll_j") * 100.0, + result["aero_j"] / 1000.0, share(result, "aero_j") * 100.0, + result["brake_j"] / 1000.0, share(result, "brake_j") * 100.0, + result["ke_j"] / 1000.0, share(result, "ke_j") * 100.0)) + lines.append(u"续航:百公里 %.2f kWh,满电 %.1f km" + % (per_100km(result), range_km(spec, result))) + 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) + + +DEFAULT_CYCLE = [ + (5.0, 0.0, 30.0), + (10.0, 30.0, 30.0), + (6.0, 30.0, 50.0), + (15.0, 50.0, 50.0), + (8.0, 50.0, 0.0), + (6.0, 0.0, 0.0), + (6.0, 0.0, 40.0), + (4.0, 40.0, 40.0), +] + + +class EnergyParams(object): + """把 /xxx/yyy 形式的参数名收成对象,缺省时用内置默认值。""" + + def __init__(self, **kwargs): + self.vehicle = VehicleSpec( + mass=kwargs.get("vehicle/mass", 1800.0), + c_rr=kwargs.get("vehicle/c_rr", 0.012), + cd=kwargs.get("vehicle/cd", 0.31), + area=kwargs.get("vehicle/area", 2.2), + battery_kwh=kwargs.get("vehicle/battery_kwh", 60.0), + regen_eff=kwargs.get("vehicle/regen_eff", 0.6), + ) + self.breakdown_tolerance = kwargs.get("check/breakdown_tolerance", 0.02) + self.regen_limit = kwargs.get("check/regen_limit", 1.0) + self.range_tolerance = kwargs.get("check/range_tolerance", 0.02) + self.dt = kwargs.get("cycle/dt", 0.05) + self.cycle = kwargs.get("cycle/segments", DEFAULT_CYCLE) diff --git a/src/ground/drive_cycle_energy/scripts/energy_node.py b/src/ground/drive_cycle_energy/scripts/energy_node.py new file mode 100644 index 0000000000..4112bd7ede --- /dev/null +++ b/src/ground/drive_cycle_energy/scripts/energy_node.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""工况能耗节点的 ROS 封装(ROS 1 / Melodic;Python 2.7 & 3.x)。 + +节点只做三件事: + 1. 从参数服务器读整车参数与工况参数; + 2. 调 energy_core 积分出一段工况的能量与续航,跑四条断言; + 3. 把报告、逐项能量(CSV)、续航分别发布到三个 latched 话题,然后打印一遍并保活。 + +注意:roslaunch 打出的日志由 rosgraph 转成 Python 2 的 str,如果消息里有中文, +必须先在 _log() 里 encode 成 byte str,否则 Melodic 的 roslogging 会抛 +UnicodeEncodeError(rosgraph/roslogging.py:249 的 str(record_message))。 +""" + +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 rospy # noqa: E402 +from std_msgs.msg import Float64, String # noqa: E402 + +import energy_core as core # noqa: E402 + +PARAM_KEYS = ( + "vehicle/mass", "vehicle/c_rr", "vehicle/cd", "vehicle/area", + "vehicle/battery_kwh", "vehicle/regen_eff", + "check/breakdown_tolerance", "check/regen_limit", + "rate/publish_hz", "topic/report", "topic/breakdown", "topic/range", +) + +DEFAULT_CYCLE = core.DEFAULT_CYCLE + + +def _log(level, msg): + """把 unicode 消息压成 byte str 再交给 rospy,规避 Melodic 的编码问题。""" + text = msg + if isinstance(text, type(u"")): + text = text.encode("utf-8", "replace") + getattr(rospy, level)(text) + + +def read_params(): + values = {} + for key in PARAM_KEYS: + values[key] = rospy.get_param("/" + key) + return values + + +def main(): + rospy.init_node("drive_cycle_energy", anonymous=False) + params = read_params() + + spec = core.VehicleSpec( + mass=params["vehicle/mass"], + c_rr=params["vehicle/c_rr"], + cd=params["vehicle/cd"], + area=params["vehicle/area"], + battery_kwh=params["vehicle/battery_kwh"], + regen_eff=params["vehicle/regen_eff"], + ) + + report_pub = rospy.Publisher(params["topic/report"], String, queue_size=1, + latch=True) + breakdown_pub = rospy.Publisher(params["topic/breakdown"], String, + queue_size=1, latch=True) + range_pub = rospy.Publisher(params["topic/range"], Float64, queue_size=1, + latch=True) + + _log("loginfo", u"工况能耗节点已启动:电池 %.1f kWh,回收 η %.2f,工况 %d 段" + % (spec.battery_kwh, spec.regen_eff, len(DEFAULT_CYCLE))) + + result = core.simulate(spec, DEFAULT_CYCLE) + asserts = core.check_energy( + spec, result, + breakdown_tolerance=params["check/breakdown_tolerance"], + regen_limit=params["check/regen_limit"], + range_tolerance=0.02, + ) + report = core.format_report(spec, result, asserts) + for line in report.splitlines(): + _log("loginfo", line) + + keys = ("roll_j", "aero_j", "brake_j", "regen_j", "ke_j", "drive_j", "net_j") + csv_text = "item,joules\n" + "\n".join( + "%s,%.3f" % (k, result[k]) for k in keys) + _log("loginfo", core.render_energy(result)) + + report_pub.publish(report) + breakdown_pub.publish(csv_text) + range_pub.publish(core.range_km(spec, result)) + _log("loginfo", u"已发布 %s / %s / %s" + % (params["topic/report"], params["topic/breakdown"], + params["topic/range"])) + + rate = rospy.Rate(params["rate/publish_hz"]) + while not rospy.is_shutdown(): + try: + rate.sleep() + except rospy.ROSInterruptException: + break + _log("loginfo", u"已退出") + + +if __name__ == "__main__": + main() diff --git a/src/ground/drive_cycle_energy/scripts/main.py b/src/ground/drive_cycle_energy/scripts/main.py new file mode 100644 index 0000000000..8af1122506 --- /dev/null +++ b/src/ground/drive_cycle_energy/scripts/main.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""入口:把脚本目录加进 sys.path 后转交给 energy_node.main。""" + +from __future__ import division, print_function + +import os +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +if HERE not in sys.path: + sys.path.insert(0, HERE) + +from energy_node import main # noqa: E402 + + +if __name__ == "__main__": + main() From 22d59e039fdeaa534a37e8935a4d62ec038dcee3 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:32:42 +0800 Subject: [PATCH 2/6] Add files via upload --- tests/test_drive_cycle_energy_local.py | 461 +++++++++++++++++++++++++ 1 file changed, 461 insertions(+) create mode 100644 tests/test_drive_cycle_energy_local.py diff --git a/tests/test_drive_cycle_energy_local.py b/tests/test_drive_cycle_energy_local.py new file mode 100644 index 0000000000..706096a12e --- /dev/null +++ b/tests/test_drive_cycle_energy_local.py @@ -0,0 +1,461 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""drive_cycle_energy 模块的离线回归测试。 + +特点: +* 只用 Python 标准库,**不需要 ROS、不需要 CARLA、不需要显示器**; +* 同时兼容 Python 2.7 与 Python 3.x(Melodic 与 Noetic 都能直接跑); +* 在仓库根目录执行:python3 tests/test_drive_cycle_energy_local.py + +覆盖范围: +A VehicleSpec 参数 B 阻力计算 C 工况解析 +D 工况积分 E 四条断言 F 能量恒等式 +G 续航与百公里能耗 H 字符图 I 报告文本 +J 参数对象 K 工程文件约定(含脚本编码声明的回归检查) + +脚本编码声明这一组(K)是专门为本项目踩过的坑加的:Melodic 的 Python 2.7 +要求每个 .py 的第 1 或第 2 行有 `# -*- coding: utf-8 -*-`,而 `sed` 改 shebang +时若把第 1 行整行覆盖,编码声明就会丢失,节点一启动就 SyntaxError。 +下面 K 组会逐个文件检查「第 1 行是 shebang、第 2 行是编码声明」。 +""" + +from __future__ import division, print_function + +import io +import os +import sys + +try: + text_type = unicode # noqa: F821 # Python 2 +except NameError: + text_type = str # Python 3 + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(HERE) + +PKG = os.path.join(ROOT, "src", "ground", "drive_cycle_energy") +SCRIPTS = os.path.join(PKG, "scripts") + +if SCRIPTS not in sys.path: + sys.path.insert(0, SCRIPTS) + +import energy_core as core # noqa: E402 + +PASSED = [] +FAILED = [] + +SPEC = core.VehicleSpec() +CYCLE = core.DEFAULT_CYCLE +RESULT = core.simulate(SPEC, CYCLE) +ASSERTS = core.check_energy(SPEC, RESULT) + + +def check(desc, expected, actual, tol=1e-9): + ok = False + if isinstance(expected, (list, tuple)) and isinstance(actual, (list, tuple)): + if expected and isinstance(expected[0], text_type): + ok = list(expected) == list(actual) + else: + ok = len(expected) == len(actual) and all( + abs(a - b) <= tol for a, b in zip(expected, actual)) + elif isinstance(expected, bool) or isinstance(actual, bool): + ok = bool(expected) == bool(actual) + elif isinstance(expected, text_type) or isinstance(actual, text_type): + ok = expected == actual + else: + ok = abs(float(expected) - float(actual)) <= max( + tol, abs(float(expected)) * 1e-12) + if ok: + PASSED.append(desc) + return True + FAILED.append(u"%s(期望 %r,实际 %r)" % (desc, expected, actual)) + return False + + +def raises(exc, fn, *args, **kwargs): + try: + fn(*args, **kwargs) + except exc: + return True + except Exception as other: # noqa: BLE001 + FAILED.append(u"应抛 %s,实际抛 %r" % (exc.__name__, other)) + return False + FAILED.append(u"应抛 %s,实际没有抛" % (exc.__name__,)) + return False + + +def read(path): + with io.open(path, "rb") as fh: + return fh.read().decode("utf-8") + + +def read_first_lines(path, count=2): + with io.open(path, "rb") as fh: + text = fh.read().decode("utf-8") + return text.splitlines()[:count] + + +# ---------------------------------------------------------------- A 参数 ---- +def group_params(): + s = core.VehicleSpec() + check(u"A1 质量", 1800.0, s.mass) + check(u"A2 滚阻系数", 0.012, s.c_rr) + check(u"A3 风阻系数", 0.31, s.cd) + check(u"A4 迎风面积", 2.2, s.area) + check(u"A5 电池容量", 60.0, s.battery_kwh) + check(u"A6 回收效率", 0.6, s.regen_eff) + check(u"A7 电池焦耳", 2.16e8, s.battery_joules()) + check(u"A8 质量必须为正", True, + raises(core.EnergyError, core.VehicleSpec, mass=0.0)) + check(u"A9 电池必须为正", True, + raises(core.EnergyError, core.VehicleSpec, battery_kwh=0.0)) + check(u"A10 风阻系数必须为正", True, + raises(core.EnergyError, core.VehicleSpec, cd=0.0)) + check(u"A11 回收效率不能大于 1", True, + raises(core.EnergyError, core.VehicleSpec, regen_eff=1.2)) + check(u"A12 回收效率可以为 0", 0.0, core.VehicleSpec(regen_eff=0.0).regen_eff) + check(u"A13 滚阻系数可以为 0", 0.0, core.VehicleSpec(c_rr=0.0).c_rr) + check(u"A14 滚阻系数不能为负", True, + raises(core.EnergyError, core.VehicleSpec, c_rr=-0.01)) + check(u"A15 repr 含 mass", True, "mass=1800" in repr(s)) + + +# ---------------------------------------------------------------- B 阻力 ---- +def group_forces(): + s = core.VehicleSpec() + check(u"B1 滚阻力恒定", 211.896, s.rolling_force()) + check(u"B2 10 m/s 风阻", 40.92, s.aero_force(10.0)) + check(u"B3 30 m/s 风阻", 368.28, s.aero_force(30.0)) + check(u"B4 0 m/s 风阻为零", 0.0, s.aero_force(0.0)) + check(u"B5 风阻按平方增长", 9.0, s.aero_force(30.0) / s.aero_force(10.0)) + check(u"B6 总阻力 = 滚阻 + 风阻", 252.816, s.resistance(10.0)) + check(u"B7 50 km/h 总阻力", 290.831185, s.resistance(50.0 / 3.6), tol=1e-5) + check(u"B8 牵引力 = m·a + 阻力", 2090.831185, + s.traction_force(50.0 / 3.6, 1.0), tol=1e-5) + check(u"B9 匀减速时牵引力为负", True, + s.traction_force(50.0 / 3.6, -2.0) < 0) + check(u"B10 动能 50 km/h", 173611.1111, s.kinetic(50.0 / 3.6), tol=1e-3) + check(u"B11 动能按平方增长", 4.0, s.kinetic(20.0) / s.kinetic(10.0)) + check(u"B12 静止动能为零", 0.0, s.kinetic(0.0)) + + +# ------------------------------------------------------------ C 工况解析 ---- +def group_parse(): + segs = core.parse_segments([(5.0, 0.0, 30.0), (10.0, 30.0, 30.0)]) + check(u"C1 段数", 2, len(segs)) + check(u"C2 时长保留", 5.0, segs[0][0]) + check(u"C3 km/h 转 m/s", 30.0 / 3.6, segs[0][2], tol=1e-12) + check(u"C4 匀速段起止相同", segs[1][1], segs[1][2]) + check(u"C5 空工况报错", True, + raises(core.EnergyError, core.parse_segments, [])) + check(u"C6 段长必须为三元素", True, + raises(core.EnergyError, core.parse_segments, [(1.0, 2.0)])) + check(u"C7 时长必须为正", True, + raises(core.EnergyError, core.parse_segments, [(0.0, 0.0, 10.0)])) + check(u"C8 车速不能为负", True, + raises(core.EnergyError, core.parse_segments, [(1.0, -5.0, 10.0)])) + check(u"C9 默认工况八段", 8, len(core.DEFAULT_CYCLE)) + check(u"C10 默认工况总时长", 60.0, + sum(seg[0] for seg in core.DEFAULT_CYCLE)) + check(u"C11 默认工况起点静止", 0.0, core.DEFAULT_CYCLE[0][1]) + check(u"C12 默认工况终点 40 km/h", 40.0, core.DEFAULT_CYCLE[-1][2]) + + +# ------------------------------------------------------------ D 工况积分 ---- +def group_simulate(): + check(u"D1 总时长", 60.0, RESULT["duration_s"]) + check(u"D2 行驶距离", 512.5, RESULT["distance_m"], tol=1e-6) + check(u"D3 最高车速 km/h", 50.0, RESULT["v_max"] * 3.6, tol=1e-9) + check(u"D4 驱动能量", 407321.394176, RESULT["drive_j"], tol=1e-3) + check(u"D5 制动能量", 159646.509903, RESULT["brake_j"], tol=1e-3) + check(u"D6 回收能量 = η·制动", 0.6 * RESULT["brake_j"], RESULT["regen_j"]) + check(u"D7 滚阻能量", 108596.7, RESULT["roll_j"], tol=1e-3) + check(u"D8 风阻能量", 27967.073162, RESULT["aero_j"], tol=1e-3) + check(u"D9 动能净变化", 111111.1111, RESULT["ke_j"], tol=1e-3) + check(u"D10 净耗电 = 驱动 − 回收", 311533.488234, RESULT["net_j"], tol=1e-3) + check(u"D11 步长影响可忽略", RESULT["net_j"], + core.simulate(SPEC, CYCLE, dt=0.02)["net_j"], tol=2.0) + check(u"D12 静止工况无驱动能量", 0.0, + core.simulate(SPEC, [(5.0, 0.0, 0.0)])["drive_j"]) + check(u"D13 静止工况无距离", 0.0, + core.simulate(SPEC, [(5.0, 0.0, 0.0)])["distance_m"]) + check(u"D14 步长必须为正", True, + raises(core.EnergyError, core.simulate, SPEC, CYCLE, 0.0)) + check(u"D15 减速越快制动能量越大", True, + core.simulate(SPEC, [(5.0, 0.0, 20.0), (4.0, 20.0, 0.0)])["brake_j"] + > core.simulate(SPEC, [(5.0, 0.0, 20.0), (8.0, 20.0, 0.0)])["brake_j"]) + check(u"D16 匀速工况驱动 = 阻力做功", 0.0, + core.simulate(SPEC, [(10.0, 40.0, 40.0)])["ke_j"]) + + +# ------------------------------------------------------------ E 四条断言 ---- +def group_asserts(): + check(u"E1 断言条数", 4, len(ASSERTS)) + check(u"E2 断言名称", list(core.ASSERT_NAMES), + [a["type"] for a in ASSERTS]) + check(u"E3 默认全部通过", True, all(a["passed"] for a in ASSERTS)) + check(u"E4 每条都有 detail", True, + all(a["detail"] for a in ASSERTS)) + check(u"E5 detail 是文本", True, + all(isinstance(a["detail"], text_type) for a in ASSERTS)) + bad = core.check_energy(SPEC, RESULT, regen_limit=0.5) + check(u"E6 回收上限收紧后第一条失败", True, + not [a for a in bad if a["type"] == core.ASSERT_NAMES[1]][0]["passed"]) + check(u"E7 其余三条仍然通过", 3, + len([a for a in bad if a["passed"]])) + bad2 = core.check_energy(SPEC, RESULT, breakdown_tolerance=-0.01) + check(u"E8 分解容差不可满足时该条失败", True, + not [a for a in bad2 if a["type"] == core.ASSERT_NAMES[0]][0]["passed"]) + check(u"E9 分解失败其余通过", 3, len([a for a in bad2 if a["passed"]])) + bad3 = core.check_energy(SPEC, RESULT, aero_rising=False) + check(u"E10 反向期望时风阻条失败", True, + not [a for a in bad3 if a["type"] == core.ASSERT_NAMES[3]][0]["passed"]) + zero = core.simulate(SPEC, [(5.0, 0.0, 0.0)]) + a_zero = core.check_energy(SPEC, zero) + check(u"E11 零驱动工况分解条失败", True, + not [a for a in a_zero if a["type"] == core.ASSERT_NAMES[0]][0]["passed"]) + no_regen = core.simulate(core.VehicleSpec(regen_eff=0.0), CYCLE) + a_nr = core.check_energy(core.VehicleSpec(regen_eff=0.0), no_regen) + check(u"E12 无回收时回收比为零", 0.0, + no_regen["regen_j"] / no_regen["brake_j"]) + check(u"E13 无回收仍然四条通过", 4, + len([a for a in a_nr if a["passed"]])) + check(u"E14 回收比与 η 一致", 0.6, + RESULT["regen_j"] / RESULT["brake_j"], tol=1e-12) + rich = core.simulate(core.VehicleSpec(regen_eff=0.95), CYCLE) + check(u"E15 η=0.95 时回收比 0.95", 0.95, + rich["regen_j"] / rich["brake_j"], tol=1e-12) + check(u"E16 η=0.95 时回收条通过", True, + all(a["passed"] for a in core.check_energy( + core.VehicleSpec(regen_eff=0.95), rich))) + check(u"E17 η=0.95 净耗低于默认", True, rich["net_j"] < RESULT["net_j"]) + heavy = core.VehicleSpec(mass=3000.0) + r_heavy = core.simulate(heavy, CYCLE) + check(u"E18 车更重则驱动能量更大", True, + r_heavy["drive_j"] > RESULT["drive_j"]) + check(u"E19 车更重仍然自洽", True, + [a for a in core.check_energy(heavy, r_heavy) + if a["type"] == core.ASSERT_NAMES[0]][0]["passed"]) + slick = core.VehicleSpec(c_rr=0.006) + r_slick = core.simulate(slick, CYCLE) + check(u"E20 滚阻减半则滚阻能量约为一半", 0.5, + r_slick["roll_j"] / RESULT["roll_j"], tol=1e-12) + check(u"E21 滚阻减半续航更长", True, + core.range_km(slick, r_slick) > core.range_km(SPEC, RESULT)) + check(u"E22 断言结果带 passed 布尔", True, + all(isinstance(a["passed"], bool) for a in ASSERTS)) + + +# ------------------------------------------------------------ F 恒等式 ---- +def group_identity(): + total = (RESULT["roll_j"] + RESULT["aero_j"] + RESULT["brake_j"] + + RESULT["ke_j"]) + check(u"F1 分解和等于驱动能量", RESULT["drive_j"], total, tol=1e-6) + check(u"F2 驱动减制动等于净机械能", RESULT["drive_j"] - RESULT["brake_j"], + RESULT["roll_j"] + RESULT["aero_j"] + RESULT["ke_j"], tol=1e-6) + check(u"F3 动能等于 0.5·m·v²", 0.5 * 1800.0 * (40.0 / 3.6) ** 2, + RESULT["ke_j"], tol=1e-6) + check(u"F4 滚阻能量等于滚阻力乘距离", 211.896 * RESULT["distance_m"], + RESULT["roll_j"], tol=1e-6) + check(u"F5 风阻能量等于 ∫F·v", 27967.073162, RESULT["aero_j"], tol=1e-3) + check(u"F6 净耗等于驱动减回收", RESULT["drive_j"] - RESULT["regen_j"], + RESULT["net_j"], tol=1e-9) + check(u"F7 回收是制动的 60%", 0.6 * RESULT["brake_j"], + RESULT["regen_j"], tol=1e-9) + check(u"F8 三项占比之和为 1", 1.0, + sum(core.share(RESULT, k) for k in ("roll_j", "aero_j", "brake_j", "ke_j")), + tol=1e-9) + check(u"F9 滚阻占比", 0.266612, core.share(RESULT, "roll_j"), tol=1e-5) + check(u"F10 风阻占比", 0.068661, core.share(RESULT, "aero_j"), tol=1e-5) + check(u"F11 制动占比", 0.391933, core.share(RESULT, "brake_j"), tol=1e-5) + check(u"F12 动能占比", 0.272785, core.share(RESULT, "ke_j"), tol=1e-5) + check(u"F13 占比非法时抛错", True, + raises(core.EnergyError, core.share, + {"drive_j": 0.0, "roll_j": 0.0}, "roll_j")) + + +# ------------------------------------------------------ G 续航与百公里 ---- +def group_range(): + check(u"G1 百公里电耗", 16.885284, core.per_100km(RESULT), tol=1e-5) + check(u"G2 满电续航", 355.339006, core.range_km(SPEC, RESULT), tol=1e-4) + check(u"G3 续航 = 电池/百公里×100", 60.0 / 16.885284 * 100.0, + core.range_km(SPEC, RESULT), tol=1e-3) + hw = core.simulate(SPEC, [(20.0, 100.0, 100.0)]) + check(u"G4 高速匀速百公里电耗", 14.656576, core.per_100km(hw), tol=1e-5) + check(u"G5 高速续航", 60.0 / core.per_100km(hw) * 100.0, + core.range_km(SPEC, hw), tol=1e-9) + check(u"G6 城市工况百公里高于高速", True, + core.per_100km(RESULT) > core.per_100km(hw)) + check(u"G7 电池减半续航减半", 0.5, + core.range_km(core.VehicleSpec(battery_kwh=30.0), RESULT) + / core.range_km(SPEC, RESULT), tol=1e-9) + check(u"G8 零距离无法折算", True, + raises(core.EnergyError, core.per_100km, {"distance_m": 0.0, + "net_j": 0.0})) + check(u"G9 净耗非正无法算续航", True, + raises(core.EnergyError, core.range_km, SPEC, + {"distance_m": 100.0, "net_j": 0.0})) + check(u"G10 无回收时续航变短", True, + core.range_km(core.VehicleSpec(regen_eff=0.0), + core.simulate(core.VehicleSpec(regen_eff=0.0), CYCLE)) + < core.range_km(SPEC, RESULT)) + + +# ------------------------------------------------------------ H 字符图 ---- +def group_render(): + art = core.render_energy(RESULT) + lines = art.splitlines() + check(u"H1 行数 = 2 + 6 + 1", 9, len(lines)) + check(u"H2 含各项标签", True, all(k in art for k in (u"滚阻", u"风阻", u"制动", + u"动能", u"驱动", u"回收"))) + check(u"H3 驱动条最长(42 格)", 42, + max(line.count("#") for line in lines)) + check(u"H4 含千焦单位", True, u"kJ" in art) + check(u"H5 自定义宽度生效", True, + core.render_energy(RESULT, width=10).splitlines()[1].count("-") == 10) + check(u"H6 空能量不崩", True, u"kJ" in core.render_energy( + {"roll_j": 0.0, "aero_j": 0.0, "brake_j": 0.0, "ke_j": 0.0, + "drive_j": 0.0, "regen_j": 0.0})) + + +# ------------------------------------------------------------ I 报告 ---- +def group_report(): + text = core.format_report(SPEC, RESULT, ASSERTS) + check(u"I1 含工况行", True, u"工况:60.0 s" in text) + check(u"I2 含整车行", True, u"电池 60.0 kWh" in text) + check(u"I3 含分解行", True, u"分解:" in text) + check(u"I4 含续航行", True, u"续航:百公里" in text) + check(u"I5 四条 PASS", 4, text.count(u"[PASS]")) + check(u"I6 结论 PASSED", True, u"结论:PASSED" in text) + check(u"I7 断言统计行", True, u"4 通过 / 0 失败" in text) + bad = core.check_energy(SPEC, RESULT, regen_limit=0.5) + bad_text = core.format_report(SPEC, RESULT, bad) + check(u"I8 失败时结论 FAILED", True, u"结论:FAILED" in bad_text) + check(u"I9 失败时统计正确", True, u"3 通过 / 1 失败" in bad_text) + + +# ------------------------------------------------------------ J 参数对象 ---- +def group_params_obj(): + p = core.EnergyParams() + check(u"J1 默认质量", 1800.0, p.vehicle.mass) + check(u"J2 默认回收效率", 0.6, p.vehicle.regen_eff) + check(u"J3 默认分解容差", 0.02, p.breakdown_tolerance) + check(u"J4 默认回收上限", 1.0, p.regen_limit) + check(u"J5 默认步长", 0.05, p.dt) + check(u"J6 默认工况段数", 8, len(p.cycle)) + q = core.EnergyParams(**{"vehicle/mass": 2400.0, "vehicle/regen_eff": 0.8, + "check/regen_limit": 0.9, "cycle/dt": 0.1}) + check(u"J7 覆盖质量", 2400.0, q.vehicle.mass) + check(u"J8 覆盖回收", 0.8, q.vehicle.regen_eff) + check(u"J9 覆盖上限", 0.9, q.regen_limit) + check(u"J10 覆盖步长", 0.1, q.dt) + + +# --------------------------------------------------- K 工程文件约定 ---- +def group_files(): + script_names = ("main.py", "energy_core.py", "energy_node.py") + for name in script_names: + path = os.path.join(SCRIPTS, name) + exists = os.path.isfile(path) + check(u"K1 %s 存在" % name, True, exists) + if not exists: + continue + first = read_first_lines(path, 2) + check(u"K2 %s 第 1 行是 shebang" % name, True, + len(first) >= 1 and first[0].startswith("#!")) + check(u"K3 %s 第 2 行是编码声明" % name, True, + len(first) >= 2 and u"coding: utf-8" in first[1]) + check(u"K4 %s 含 __future__" % name, True, + u"from __future__" in read(path)) + + check(u"K5 core 不 import rospy", False, + "import rospy" in read(os.path.join(SCRIPTS, "energy_core.py"))) + check(u"K6 core 不 import numpy", False, + "import numpy" in read(os.path.join(SCRIPTS, "energy_core.py"))) + check(u"K7 node 含 _log 辅助", True, + "def _log" in read(os.path.join(SCRIPTS, "energy_node.py"))) + check(u"K8 node 用 latched 发布", True, + "latch=True" in read(os.path.join(SCRIPTS, "energy_node.py"))) + check(u"K9 yaml 存在", True, + os.path.isfile(os.path.join(PKG, "config", "drive_cycle_energy.yaml"))) + check(u"K10 launch 存在", True, + os.path.isfile(os.path.join(PKG, "launch", "main.launch"))) + launch = read(os.path.join(PKG, "launch", "main.launch")) + check(u"K11 launch 用 main.py", True, 'type="main.py"' in launch) + check(u"K12 launch 加载 yaml", True, "rosparam command=\"load\"" in launch) + check(u"K13 launch 里 12 个 param", 12, launch.count(" before_fail: + raise AssertionError( + u"本组失败 %d 项:%s" % (len(FAILED) - before_fail, + FAILED[-1])) + runner.__name__ = fn.__name__ + return runner + + +def main(): + lines = [] + lines.append(u"drive_cycle_energy 离线回归测试") + lines.append(u"Python %s" % sys.version.split()[0]) + lines.append(u"包目录 %s" % PKG) + lines.append(u"-" * 60) + for title, fn in GROUP_FUNCS: + before = len(FAILED) + fn() + bad = len(FAILED) - before + lines.append(u"%-22s %s" % (title, u"PASS" if bad == 0 else u"FAIL(%d)" % bad)) + lines.append(u"=" * 60) + lines.append(u"通过 %d 项,失败 %d 项" % (len(PASSED), len(FAILED))) + for item in FAILED: + lines.append(u" [FAIL] %s" % item) + lines.append(u"全部通过" if not FAILED else u"结论:FAILED") + print(u"\n".join(lines)) + return 0 if not FAILED else 1 + + +test_A_parameters = _pytest_group(group_params) +test_B_forces = _pytest_group(group_forces) +test_C_parse = _pytest_group(group_parse) +test_D_simulate = _pytest_group(group_simulate) +test_E_asserts = _pytest_group(group_asserts) +test_F_identity = _pytest_group(group_identity) +test_G_range = _pytest_group(group_range) +test_H_render = _pytest_group(group_render) +test_I_report = _pytest_group(group_report) +test_J_params = _pytest_group(group_params_obj) +test_K_files = _pytest_group(group_files) + + +if __name__ == "__main__": + sys.exit(main()) From 167e26370fd38dc74b8c90efdefd052206e1d540 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:33:14 +0800 Subject: [PATCH 3/6] Add files via upload --- docs/ground/drive_cycle_energy.md | 207 ++++++++++++++++++++++++++++++ 1 file changed, 207 insertions(+) create mode 100644 docs/ground/drive_cycle_energy.md diff --git a/docs/ground/drive_cycle_energy.md b/docs/ground/drive_cycle_energy.md new file mode 100644 index 0000000000..fca04a3c8c --- /dev/null +++ b/docs/ground/drive_cycle_energy.md @@ -0,0 +1,207 @@ +# 工况能耗与续航核算(`drive_cycle_energy`) + +> 一段行驶工况里,电池的电到底花在哪里?滚阻、风阻、制动损失、动能各占多少? +> 再生制动能收回多少?满电能跑多远? +> 本模块用纵向动力学把这几件事算成一组**可断言的数字**,并在终端打印能量条。 + +## 模块概述 + +输入是一段**工况**(每段写成「时长 + 起始车速 + 结束车速」)和一组整车参数, +输出是: + +- 驱动能量、制动能量、回收能量、净耗电量; +- 能量分解:滚阻 / 风阻 / 制动损失 / 动能净变化; +- 百公里电耗与满电续航; +- 四条断言(能量分解自洽、回收上限、续航自洽、风阻随车速上升)。 + +**为什么值得单独做一个模块**:运动学模块(如 `speed_profile_check`)能算出 +「什么时候该加速、什么时候该减速」,但它不算阻力,也就无法回答「这么开费多少电」。 +本模块补上纵向阻力与电池模型,并且因为能量分解可以写成闭式恒等式, +「实现对不对」能被断言直接卡住,不需要仿真器。 + +## 构建与运行 + +本包是纯 Python 的 catkin 包,`catkin_make` 只做安装,不编译 C++: + +```bash +cd ~/catkin_ws18 +catkin_make +source /opt/ros/melodic/setup.bash +source devel/setup.bash +roslaunch drive_cycle_energy main.launch +``` + +命令行覆盖参数(优先级:命令行 > yaml > 代码默认值): + +```bash +roslaunch drive_cycle_energy main.launch regen_eff:=0.0 +roslaunch drive_cycle_energy main.launch regen_limit:=0.5 +roslaunch drive_cycle_energy main.launch battery_kwh:=30.0 +``` + +## 模型 + +纵向动力学(忽略坡度,纵向加速度记为 a): + +``` +驱动力 F = m·a + m·g·c_rr + 0.5·ρ·Cd·A·v² +滚阻力 F_rr = m·g·c_rr +风阻力 F_aero = 0.5·ρ·Cd·A·v² +``` + +能量按时间积分: + +``` +E_drive = ∫ max(F, 0)·v dt 驱动能量 +E_brake = ∫ max(−F, 0)·v dt 制动能量(被消耗掉的机械能) +E_regen = η · E_brake 再生制动回收 +E_net = E_drive − E_regen 净耗电 +``` + +核心恒等式(第一条断言的依据): + +``` +E_drive = E_roll + E_aero + E_brake + ΔKE +``` + +其中 `ΔKE = 0.5·m·(v_end² − v_start²)` 是整段工况的动能净变化。 +滚阻与风阻都能写成速度的幂函数(`v` 与 `v³`),所以三项都可以逐点积出来再对账。 + +续航: + +``` +百公里电耗 = E_net / 3.6e6 / (距离 / 100 km) [kWh/100km] +续航 = 电池容量 / 百公里电耗 × 100 [km] +``` + +## 四条断言 + +| 断言 | 判据 | 失败意味着 | +|---|---|---| +| **能量分解** | 滚阻+风阻+制动+动能 与驱动能量的相对偏差 ≤ `breakdown_tolerance` | 积分或阻力模型实现错了 | +| **回收上限** | `E_regen / E_brake ≤ regen_limit` | 回收效率配置不合理(η 越界或断言被放宽) | +| **续航自洽** | 由百公里电耗反推的续航与直接算的一致 | 折算公式实现不一致 | +| **风阻上升** | 30 m/s 风阻 > 10 m/s 风阻 | 风阻没按 v² 算(最常见是把线性项当二次项) | + +## 参数 + +| 参数 | 默认 | 说明 | +|---|---|---| +| `vehicle/mass` | 1800.0 | 整备质量 kg | +| `vehicle/c_rr` | 0.012 | 滚动阻力系数 | +| `vehicle/cd` | 0.31 | 风阻系数 | +| `vehicle/area` | 2.2 | 迎风面积 m² | +| `vehicle/battery_kwh` | 60.0 | 电池可用容量 kWh | +| `vehicle/regen_eff` | 0.6 | 再生制动效率 0~1 | +| `check/breakdown_tolerance` | 0.02 | 能量分解相对偏差上限 | +| `check/regen_limit` | 1.0 | 回收 / 制动 上限 | +| `rate/publish_hz` | 10.0 | 保活循环频率 Hz | +| `topic/report` | `/energy/report` | 文字报告话题 | +| `topic/breakdown` | `/energy/breakdown` | 逐项能量 CSV | +| `topic/range` | `/energy/range` | 满电续航 km | + +`launch/main.launch` 为每个参数都声明了带 `doc` 的 `` 并写回同名 ``, +所以命令行覆盖一定生效(不像写错的 `$(rospack find …)` 那样静默失败)。 + +## 话题 + +| 话题 | 类型 | 内容 | +|---|---|---| +| `/energy/report` | `std_msgs/String` | 完整文字报告(latched) | +| `/energy/breakdown` | `std_msgs/String` | `item,joules` 七行 CSV(latched) | +| `/energy/range` | `std_msgs/Float64` | 满电续航 km(latched) | + +```bash +rostopic echo -n 1 /energy/report +rostopic echo -n 1 /energy/breakdown +rostopic echo -n 1 /energy/range +``` + +## 实测输出(默认工况) + +默认工况 8 段共 60 s(0→30、30 匀速、30→50、50 匀速、50→0、怠速、0→40、40 匀速), +行驶 512.5 m,最高 50 km/h: + +``` +工况:60.0 s,行驶 512.5 m,最高 50.0 km/h +整车:质量 1800 kg,滚阻 0.012,Cd·A 0.68 m²,电池 60.0 kWh,回收 η 0.60 +能量:驱动 407.3 kJ,制动 159.6 kJ,回收 95.8 kJ,净耗 311.5 kJ +分解:滚阻 108.6 kJ(26.7%),风阻 28.0 kJ(6.9%),制动 159.6 kJ(39.2%),动能 111.1 kJ(27.3%) +续航:百公里 16.89 kWh,满电 355.3 km +断言:4 通过 / 0 失败(共 4 条) + [PASS] 能量分解 … 相对偏差 0.0000,容差 0.02 + [PASS] 回收上限 回收 95.8 / 制动 159.6 = 0.6000(上限 1.00,η=0.60) + [PASS] 续航自洽 百公里 16.885 kWh,电池 60.0 kWh → 续航 355.3 km + [PASS] 风阻上升 10 m/s 风阻 40.9 N,30 m/s 风阻 368.3 N(期望上升) +结论:PASSED +``` + +能量条(驱动为满条,其余按比例): + +``` +滚阻|###########| 108.6 kJ +风阻|###| 28.0 kJ +制动|################| 159.6 kJ +动能|###########| 111.1 kJ +驱动|##########################################| 407.3 kJ +回收|##########| 95.8 kJ +``` + +## 两个反例 + +**反例一**:`regen_limit:=0.5` —— 回收比 0.6000 超过上限,只翻「回收上限」,其余三条通过。 + +**反例二**:`regen_eff:=0.0` —— 没有回收: + +| 量 | 默认(η=0.6) | 无回收(η=0) | +|---|---|---| +| 净耗 | 311.5 kJ | **407.3 kJ** | +| 满电续航 | 355.3 km | **271.8 km** | + +注意四条断言**依然全过**:它们校验的是自洽性,不是「这台车好不好」。 +想知道回收值不值,就是要像上表这样对比两次运行 —— 这正是把断言和结论分开的价值。 + +## 离线测试 + +```bash +python3 tests/test_drive_cycle_energy_local.py +``` + +**通过 152 项,失败 0 项**(Python 3.6.9 / 3.12 均可),11 组: +参数校验、阻力计算、工况解析、工况积分、四条断言、能量恒等式、续航与百公里、 +字符图、报告文本、参数对象、工程文件约定。 + +其中 K 组是本项目踩坑后的回归:**逐个检查 `scripts/*.py` 的第 1 行是 shebang、 +第 2 行是 `# -*- coding: utf-8 -*-`**。Melodic 的 Python 2.7 只在前两行找编码声明, +用 `sed -i '1s|.*|#!/usr/bin/env python2|'` 整行覆盖会把编码声明顶掉, +节点一启动就报 `SyntaxError: Non-ASCII character ... but no encoding declared`。 +现在的写法是带锚点的 `sed -i '1s|^#!/usr/bin/env python$|#!/usr/bin/env python2|'`, +并且三个脚本都保证「第 1 行 shebang、第 2 行编码声明」。 + +## 与其他模块的分工 + +| 模块 | 回答的问题 | +|---|---| +| `speed_profile_check` | 一段距离怎么分配加减速时间(运动学,无阻力) | +| `braking_distance_check` | 从看见到停住要几米(纵向制动,无回收) | +| `lateral_stability_margin` | 转弯稳不稳(横向,与能耗无关) | +| **本模块** | **纵向能量流:滚阻 / 风阻 / 制动 / 动能分配 + 续航** | + +## 常见问题 + +**Q:`rostopic echo` 卡住了?** +latched 话题会持续重发最后一条,加 `-n 1` 取一条。 + +**Q:`rosparam get` 提示 `is not set`?** +说明 `roslaunch` 已经退出;重跑 launch,让它挂着别关。 + +**Q:想用自己的工况?** +改 `scripts/energy_core.py` 末尾的 `DEFAULT_CYCLE`,每段是 +`(时长秒, 起始 km/h, 结束 km/h)`;或在交互式 Python 里直接 +`core.simulate(spec, [(5.0, 0.0, 60.0)])` 试算。 + +**Q:为什么没有 slope(坡度)?** +为了让能量分解保持闭式、可断言;坡度会把 `m·g·sinθ·v` 这一项混进来, +需要在 `traction_force` 里再加一个参数,属于可扩展项,不影响当前结论。 + +> 所使用具体的大模型声明:使用大模型辅助代码编写、测试编写与文档整理,提交内容由本人负责。 From ecb988bb0ccbc6c6e6adf14b029d77b901b9c8a7 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:33:46 +0800 Subject: [PATCH 4/6] Update mkdocs.yml --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index e20a6daa36..db41cc1d11 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -221,6 +221,7 @@ nav: - 转弯扫掠校验: './ground/turning_sweep_check.md' - 高精度定位与重定位(AMCL 式粒子滤波): './ground/turtlebot3_relocalization.md' - 速度指令安全监督: './ground/cmd_vel_guard.md' + - 工况能耗与续航: './ground/drive_cycle_energy.md' - 空域载具: - MuJoCo 城市屋顶光伏覆盖率测量: './air/mujoco_uav_rooftop_pv_coverage_survey.md' From 971a720acad1fec0b27fbe86c588b711cdd026fb Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:34:32 +0800 Subject: [PATCH 5/6] Add section on energy consumption and range Added a new section on energy consumption and range during driving cycles. --- docs/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index fcfb8c3e75..dabb4f663f 100644 --- a/docs/index.md +++ b/docs/index.md @@ -228,7 +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/drive_cycle_energy.md) —— 把一次行驶的驱动/制动/回收能量拆开,复算百公里电耗与满电续航 ## 5. 空域载具 * [多无人机空域监测(多边形禁飞区与机间冲突)](./air/multi_uav_airspace_monitor.md) —— 面向多机轨迹的电子围栏、最近接近距离和冲突解脱建议 From 4bf8d436e0fd51dffa8076b5893620ac55c91632 Mon Sep 17 00:00:00 2001 From: Wist-sutton <3473325902@qq.com> Date: Wed, 11 Nov 2026 19:40:24 +0800 Subject: [PATCH 6/6] Update mkdocs.yml --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index 8daccb3071..8625cbfa2a 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -224,6 +224,7 @@ nav: - 转弯扫掠校验: './ground/turning_sweep_check.md' - 高精度定位与重定位(AMCL 式粒子滤波): './ground/turtlebot3_relocalization.md' - 速度指令安全监督: './ground/cmd_vel_guard.md' + - 乘坐舒适性传递率: './ground/ride_comfort_transmissibility.md' - 空域载具: - MuJoCo 城市屋顶光伏覆盖率测量: './air/mujoco_uav_rooftop_pv_coverage_survey.md'