N·m/kg 是“重量扭矩密度”的常用单位，表示每千克质量能够输出的扭矩大小

Borter

6人浏览 · 2026-11-10 00:00:00

Borter · 2026-11-10 00:00:00 发布

N·m/kg 是“重量扭矩密度”的常用单位，表示每千克质量能够输出的扭矩大小。其基本公式为：

扭矩密度 = 额定扭矩 / 质量

其中，扭矩单位为 N·m，质量单位为 kg，结果单位为 N·m/kg。
这个指标常用于电机、关节模组、轮毂电机、机器人关节、航空电动发动机、风电齿轮箱等场景，用来衡量“单位重量下能输出多少扭矩”。数值越高，通常意味着系统越紧凑、轻量化能力越强。

下面给出一份可直接运行的 Python 报告，包含基础计算、批量对比、功率—转速换算、可视化、单位换算和异常数据处理。

一、报告目标

理解 N·m/kg 的物理含义。
用 Python 实现扭矩密度计算。
支持从功率和转速反推扭矩。
对多个关节模组或电机进行横向比较。
用柱状图直观展示扭矩密度差异。
处理常见工程问题，例如单位不一致、数据缺失、异常值。

二、核心公式

重量扭矩密度：

torque_density = torque / mass

如果只有功率和转速，可用工程常用公式估算扭矩：

T = 9550 * P / n

其中：

T：扭矩，单位 N·m；
P：功率，单位 kW；
n：转速，单位 rpm。

注意：这里的 9550 是近似常数，来源于：

60 * 1000 / (2 * pi) ≈ 9549.3 ≈ 9550

三、Python 代码

"""
扭矩密度 N·m/kg 计算与分析脚本
功能：
1. 基础扭矩密度计算
2. 功率-转速反推扭矩
3. 批量对比不同电机/关节模组
4. 可视化柱状图
5. 单位换算与异常数据过滤
"""

import math
import matplotlib.pyplot as plt

# ----------------------------
# 1. 基础计算函数
# ----------------------------

def torque_density(torque: float, mass: float) -> float:
    """
    计算扭矩密度，单位 N·m/kg
    :param torque: 扭矩，单位 N·m
    :param mass: 质量，单位 kg
    :return: 扭矩密度，单位 N·m/kg
    """
    if mass <= 0:
        raise ValueError("质量必须大于 0")
    return torque / mass


def torque_from_power_speed(power_kw: float, speed_rpm: float) -> float:
    """
    通过功率和转速估算扭矩
    公式：T = 9550 * P / n
    :param power_kw: 功率，单位 kW
    :param speed_rpm: 转速，单位 rpm
    :return: 扭矩，单位 N·m
    """
    if speed_rpm <= 0:
        raise ValueError("转速必须大于 0")
    return 9550 * power_kw / speed_rpm


# ----------------------------
# 2. 单个案例演示
# ----------------------------

print("=" * 50)
print("案例 1：单个关节模组扭矩密度计算")
print("=" * 50)

torque_1 = 30      # N·m
mass_1 = 0.57      # kg
td_1 = torque_density(torque_1, mass_1)

print(f"额定扭矩：{torque_1} N·m")
print(f"模组质量：{mass_1} kg")
print(f"扭矩密度：{td_1:.2f} N·m/kg")

# ----------------------------
# 3. 从功率和转速反推扭矩
# ----------------------------

print("\n" + "=" * 50)
print("案例 2：由功率和转速反推扭矩密度")
print("=" * 50)

power_kw = 1.5        # kW
speed_rpm = 1450      # rpm
mass_2 = 8.0          # kg

torque_2 = torque_from_power_speed(power_kw, speed_rpm)
td_2 = torque_density(torque_2, mass_2)

print(f"功率：{power_kw} kW")
print(f"转速：{speed_rpm} rpm")
print(f"估算扭矩：{torque_2:.2f} N·m")
print(f"质量：{mass_2} kg")
print(f"扭矩密度：{td_2:.2f} N·m/kg")

# ----------------------------
# 4. 批量对比不同关节模组
# ----------------------------

print("\n" + "=" * 50)
print("案例 3：多个关节模组批量对比")
print("=" * 50)

motors = [
    {"name": "关节模组 A", "torque": 30,  "mass": 0.57},
    {"name": "关节模组 B", "torque": 150, "mass": 1.35},
    {"name": "关节模组 C", "torque": 380, "mass": 3.20},
    {"name": "关节模组 D", "torque": 91,  "mass": 0.83},
    {"name": "关节模组 E", "torque": 360, "mass": 2.20},
]

for m in motors:
    m["torque_density"] = torque_density(m["torque"], m["mass"])
    print(
        f"{m['name']:10s} | "
        f"扭矩 {m['torque']:6.1f} N·m | "
        f"质量 {m['mass']:5.2f} kg | "
        f"扭矩密度 {m['torque_density']:7.2f} N·m/kg"
    )

# ----------------------------
# 5. 可视化
# ----------------------------

names = [m["name"] for m in motors]
densities = [m["torque_density"] for m in motors]

plt.figure(figsize=(9, 5))
bars = plt.bar(names, densities, color=["#4C72B0", "#55A868", "#C44E52", "#8172B2", "#CCB974"])
plt.title("不同关节模组的扭矩密度对比 N·m/kg")
plt.ylabel("扭矩密度 N·m/kg")
plt.grid(axis="y", alpha=0.3)

for bar, value in zip(bars, densities):
    plt.text(
        bar.get_x() + bar.get_width() / 2,
        bar.get_height() + 1.5,
        f"{value:.1f}",
        ha="center",
        fontsize=9,
    )

plt.tight_layout()
plt.show()

# ----------------------------
# 6. 单位换算与异常数据处理
# ----------------------------

print("\n" + "=" * 50)
print("案例 4：单位换算与异常数据过滤")
print("=" * 50)

def kgf_cm_to_nm(value: float) -> float:
    """将 kgf·cm 转换为 N·m"""
    return value * 0.0980665


def nm_to_kgf_cm(value: float) -> float:
    """将 N·m 转换为 kgf·cm"""
    return value / 0.0980665


raw_data = [
    {"name": "模组 X", "torque_nm": 20,   "mass_kg": 0.5},
    {"name": "模组 Y", "torque_kgfcm": 300, "mass_kg": 0.8},
    {"name": "模组 Z", "torque_nm": -10,  "mass_kg": 1.0},   # 异常：负扭矩
    {"name": "模组 W", "torque_nm": 50,   "mass_kg": 0},     # 异常：质量为 0
]

for item in raw_data:
    name = item["name"]

    if "torque_kgfcm" in item:
        torque_nm = kgf_cm_to_nm(item["torque_kgfcm"])
    elif "torque_nm" in item:
        torque_nm = item["torque_nm"]
    else:
        print(f"{name}: 缺少扭矩数据，跳过")
        continue

    mass_kg = item["mass_kg"]

    if torque_nm <= 0 or mass_kg <= 0:
        print(f"{name}: 数据异常，跳过 | 扭矩={torque_nm:.3f} N·m, 质量={mass_kg} kg")
        continue

    td = torque_density(torque_nm, mass_kg)
    print(f"{name}: 扭矩密度 = {td:.2f} N·m/kg")

四、代码解析

1. 基础函数设计

torque_density 函数负责计算扭矩密度。它首先检查质量是否大于 0，避免除零错误。工程计算中，输入参数校验非常重要，尤其是批量处理数据时，异常值可能导致后续统计结果失真。

torque_from_power_speed 函数通过功率和转速估算扭矩。这个公式在电机选型、传动系统初步计算中很常用。

2. 单个案例演示

案例 1 模拟了一个典型关节模组：扭矩 30 N·m，质量 0.57 kg。计算结果约为 52.63 N·m/kg。这个量级可以理解为：每千克质量能够输出约 52.63 N·m 的扭矩。

3. 功率—转速反推

案例 2 展示了从功率和转速反推扭矩的过程。对于 1.5 kW、1450 rpm 的电机，估算扭矩约为 9.88 N·m。再除以质量 8 kg，得到扭矩密度约 1.24 N·m/kg。这个数值明显低于高性能关节模组，说明它更可能是一个普通工业电机，而不是轻量化机器人关节。

4. 批量对比

案例 3 用列表存储多个模组数据，并循环计算扭矩密度。实际工程中，这些数据可以来自 CSV、Excel、数据库或测试平台。使用字典结构便于扩展，例如后续增加“额定转速”“减速比”“效率”等字段。

5. 可视化

柱状图可以直观比较不同模组的扭矩密度。对于选型报告、技术评审或课程作业，图形化展示比单纯表格更容易发现性能差异。

6. 单位换算与异常处理

案例 4 处理了两种常见问题：

扭矩单位不是 N·m，而是 kgf·cm；
数据中存在负值、零值或缺失字段。

这类处理适合自动化脚本。例如批量读取实验数据时，可以先清洗，再计算，最后输出合格结果。

五、运行结果示例

程序会输出类似以下内容：

案例 1：单个关节模组扭矩密度计算
额定扭矩：30 N·m
模组质量：0.57 kg
扭矩密度：52.63 N·m/kg

案例 2：由功率和转速反推扭矩密度
功率：1.5 kW
转速：1450 rpm
估算扭矩：9.88 N·m
质量：8.0 kg
扭矩密度：1.24 N·m/kg

案例 3：多个关节模组批量对比
关节模组 A  | 扭矩   30.0 N·m | 质量  0.57 kg | 扭矩密度   52.63 N·m/kg
关节模组 B  | 扭矩  150.0 N·m | 质量  1.35 kg | 扭矩密度  111.11 N·m/kg
关节模组 C  | 扭矩  380.0 N·m | 质量  3.20 kg | 扭矩密度  118.75 N·m/kg
关节模组 D  | 扭矩   91.0 N·m | 质量  0.83 kg | 扭矩密度  109.64 N·m/kg
关节模组 E  | 扭矩  360.0 N·m | 质量  2.20 kg | 扭矩密度  163.64 N·m/kg

案例 4：单位换算与异常数据过滤
模组 X: 扭矩密度 = 40.00 N·m/kg
模组 Y: 扭矩密度 = 36.77 N·m/kg
模组 Z: 数据异常，跳过 | 扭矩=-10.000 N·m, 质量=1.0 kg
模组 W: 数据异常，跳过 | 扭矩=50.000 N·m, 质量=0 kg