新增:机械原理第4章「机械的平衡」笔记;笔记目录改为「分包」结构

一、新增 笔记/05-机械的平衡/知识点-机械的平衡.md(考纲 ⑩)
- 来源 补充资源/机械原理PPT/04 机械的平衡.ppt(olefile 抽 33 页)
- 八节:目的与内容(F=mrω²、危害三条、刚性转子判据、两大分支)/
  刚性转子平衡计算(静平衡 d/b≥5 质径积矢量式 + 双面分解;动平衡
  d/b<5 ∑F=0 且 ∑M=0、双基面两次静平衡;静↔动对比表)/ 平衡实验
  (三架对比 + 强迫振动 Z=μmr、标准转子标定 μ、相位差 α)/
  许用不平衡量与平衡精度([e]、[mr]、A=[e]ω/1000、等级 G4000~G0.4)/
  平面机构平衡(F=-ma_s=0→质心静止;完全平衡 vs 部分平衡)/ 要点回顾
  + 9 条易错 / 考纲对齐
- 按约定不配图

二、笔记目录重构为「包」结构
- 01 齿轮机构及其设计 / 02 轮系及其设计 / 03 其他常用机构 /
  04 机器的运转和调速 / 05 机械的平衡 / 06 机械零件设计基础
- 每包自带:知识点 + 背诵版 + 练习(题目卷/答案卷)+ images/
- 顶层 背诵版/ 目录取消,背诵版并入各包;images/ 按包拆分
- 绘图脚本移到 笔记/_配图脚本/,OUT 改为自动指向各包 images/
- 新增 笔记/00-总索引.md(包清单 + 考纲全景对照 + 待办)
- 文件名全部保持原样,Obsidian 双链与图片相对路径零改动

三、修复全库渲染 bug:加粗以公式结尾时失效
- `**$x$ **` 中 `**` 前是空白,CommonMark 不认其为闭合符 → 加粗失效
- 新增 .workbuddy/fix_bold_math.py(按 ** 成对解析)修掉 107 处
This commit is contained in:
2026-10-18 18:48:03 +08:00
parent ee8ef9456e
commit 39469c5b50
50 changed files with 715 additions and 196 deletions
@@ -0,0 +1,815 @@
# -*- coding: utf-8 -*-
"""
《知识点-其他常用机构(第9章)》配图生成脚本
- 全部为**几何/数学作图**(锯齿轮廓、槽轮锁止弧几何、棘爪受力分解、差动螺旋位移…),非生成式 AI。
- 复用 gen_figures.py 的绘图工具(配色 / 留白 / 注释框 / 中文字体 / 300 dpi)。
运行:python gen_figures_mechanisms.py → 输出到 ../03-其他常用机构/images/ 的 figMXX_*.png
"""
import os
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib.patches import (Circle, Rectangle, FancyBboxPatch, Polygon,
Ellipse, Wedge)
from gen_figures import (OUT, DPI, C_MAIN, C_BLUE, C_RED, C_GREEN,
C_ORANGE, C_PURPLE, C_GRAY, arc, save, note)
# 输出目录:本脚本在 笔记/_配图脚本/ 下,图归到 03 包的 images/
OUT = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"03-其他常用机构", "images")
os.makedirs(OUT, exist_ok=True)
# =====================================================================
# 基础工具
# =====================================================================
def new_ax(w=7.8, h=6.2, xlim=(-2.5, 3.2), ylim=(-1.8, 2.6)):
fig, ax = plt.subplots(figsize=(w, h))
ax.set_xlim(*xlim)
ax.set_ylim(*ylim)
ax.set_aspect("equal")
ax.axis("off")
return fig, ax
def grid(nr, nc, w, h):
fig, axes = plt.subplots(nr, nc, figsize=(w, h))
axes = np.atleast_1d(axes).ravel()
for ax in axes:
ax.set_aspect("equal")
ax.axis("off")
return fig, axes
def line(ax, p, q, color=C_GRAY, lw=1.1, ls="-", zorder=1):
ax.plot([p[0], q[0]], [p[1], q[1]], color=color, lw=lw, ls=ls, zorder=zorder)
def box(ax, x, y, w, h, s, fc="#eef4fb", ec=C_BLUE, fs=10.5, tc=None, lw=1.2,
va="center"):
ax.add_patch(FancyBboxPatch((x - w / 2, y - h / 2), w, h,
boxstyle="round,pad=0.02,rounding_size=0.06",
fc=fc, ec=ec, lw=lw, zorder=8))
ax.text(x, y, s, ha="center", va=va, fontsize=fs, zorder=9,
color=tc or C_MAIN, linespacing=1.55)
def arrow(ax, p, q, color=C_RED, lw=1.9, ls="-", zorder=7, head=0.17):
p, q = np.asarray(p, float), np.asarray(q, float)
d = q - p
L = np.hypot(*d)
if L < 1e-9:
return
d = d / L
n = np.array([-d[1], d[0]])
ax.plot([p[0], q[0]], [p[1], q[1]], color=color, lw=lw, ls=ls, zorder=zorder)
ax.add_patch(Polygon([q, q - d * head + n * head * 0.45,
q - d * head - n * head * 0.45],
closed=True, fc=color, ec=color, zorder=zorder))
def rot_arrow(ax, cx, cy, r, a0, a1, color=C_RED, lw=1.9, zorder=7,
head=0.17):
t = np.radians(np.linspace(a0, a1, 120))
ax.plot(cx + r * np.cos(t), cy + r * np.sin(t), color=color, lw=lw,
zorder=zorder)
a = np.radians(a1)
p = np.array([cx + r * np.cos(a), cy + r * np.sin(a)])
tang = np.array([-np.sin(a), np.cos(a)]) * (1.0 if a1 > a0 else -1.0)
n = np.array([-tang[1], tang[0]])
ax.add_patch(Polygon([p, p - tang * head + n * head * 0.42,
p - tang * head - n * head * 0.42],
closed=True, fc=color, ec=color, zorder=zorder))
def pawl(ax, tip, ang, L=0.62, w=0.15, color=C_MAIN, lw=1.4, zorder=6,
fc="#e9edf2"):
"""棘爪:尖端在 tip,沿 ang 方向反向延伸的锥形杆"""
d = np.array([np.cos(ang), np.sin(ang)])
n = np.array([-d[1], d[0]])
tip = np.asarray(tip, float)
base = tip - d * L
mid = tip - d * L * 0.62
ax.add_patch(Polygon([tip, mid + n * w * 0.5, base + n * w * 0.55,
base - n * w * 0.55, mid - n * w * 0.5],
closed=True, fc=fc, ec=color, lw=lw, zorder=zorder))
return base
def pivot(ax, p, r=0.075, color=C_MAIN, zorder=8):
ax.add_patch(Circle(p, r, fc="white", ec=color, lw=1.3, zorder=zorder))
ax.plot([p[0] - r * 1.6, p[0] + r * 1.6], [p[1], p[1]], color=color,
lw=0.9, zorder=zorder)
ax.plot([p[0], p[0]], [p[1] - r * 1.6, p[1] + r * 1.6], color=color,
lw=0.9, zorder=zorder)
def ratchet_outline(z=12, r_out=1.0, r_in=0.86, tilt_deg=14.0):
"""棘轮锯齿轮廓:工作面近径向(偏 tilt),齿背为直线"""
th = 2 * np.pi / z
t = np.radians(tilt_deg)
pts = []
for k in range(z):
a0 = k * th
pts.append((r_in * np.cos(a0), r_in * np.sin(a0)))
pts.append((r_out * np.cos(a0 + t), r_out * np.sin(a0 + t)))
return np.array(pts)
def geneva_wheel(z=4, L=1.0, b=0.09, r_inn=0.36, n_arc=60):
"""槽轮轮廓(外啮合):
- 锁止凹弧中心方向 θm = k·δ;径向槽中心方向 θs = θm + δ/2(δ = 360°/z)
- 凹弧:圆心在 (L, θm)、半径 r0(= 拨盘凸弧半径),自半径 s 处向内凹至 L-r0
- 径向槽:半宽 b、槽底半径 r_inn(槽底为半圆)
返回 (轮廓点集, 参数 dict)
"""
delta = 2 * np.pi / z
phi = delta / 2
R = L * np.sin(phi) # 拨盘圆销回转半径
s = L * np.cos(phi) # 槽轮半径(槽口所在圆)
r_pin = R / 6.0 # 圆销半径
r0 = R - r_pin - b # 拨盘凸锁止弧半径
# 凹弧与半径 s 圆的交点,相对 θm 的角半宽 th
th = np.arccos(np.clip((s * s + L * L - r0 * r0) / (2 * s * L), -1, 1))
xw = np.sqrt(max(s * s - b * b, 0.0)) # 槽壁与半径 s 圆交点的局部 x
hi = np.arctan2(b, xw) # 该点相对 θs 的角
xb = r_inn + b # 槽底半圆圆心局部 x
pts = []
for k in range(z):
tm = k * delta
ts = tm + delta / 2
# 1 凹锁止弧 θm-th .. θm+th
for a in np.linspace(tm - th, tm + th, n_arc):
da = a - tm
rr = L * np.cos(da) - np.sqrt(max(r0 * r0 - L * L * np.sin(da) ** 2, 0))
pts.append(rr * np.array([np.cos(a), np.sin(a)]))
# 2 槽轮半径 s 圆弧 θm+th .. θs-hi
for a in np.linspace(tm + th, ts - hi, 40):
pts.append(s * np.array([np.cos(a), np.sin(a)]))
# 3 径向槽(局部坐标 u 沿 θs)
u = np.array([np.cos(ts), np.sin(ts)])
n = np.array([-u[1], u[0]])
pts.append(xw * u - b * n)
for rp in np.linspace(270, 90, n_arc): # 槽底半圆
rr = np.radians(rp)
pts.append(xb * u + b * (np.cos(rr) * u + np.sin(rr) * n))
pts.append(xw * u + b * n)
# 4 槽轮半径 s 圆弧 θs+hi .. θm+δ-th
for a in np.linspace(ts + hi, tm + delta - th, 40):
pts.append(s * np.array([np.cos(a), np.sin(a)]))
return np.array(pts), dict(z=z, L=L, R=R, s=s, r_pin=r_pin, r0=r0,
delta=delta, th=th, hi=hi, b=b)
# =====================================================================
# figM01 棘轮机构组成与工作原理
# =====================================================================
def figM01():
fig, ax = new_ax(7.9, 6.4, (-2.55, 3.25), (-2.25, 2.60))
z, R, rin = 12, 1.0, 0.86
P = ratchet_outline(z, R, rin)
ax.add_patch(Polygon(P, closed=True, fc="#f5f7f9", ec=C_MAIN, lw=1.5,
zorder=3))
ax.add_patch(Circle((0, 0), 0.19, fc="white", ec=C_MAIN, lw=1.2, zorder=4))
pivot(ax, (0, 0), 0.05)
ax.text(0.33, -0.33, "棘轮", fontsize=11.5, color=C_MAIN, zorder=9)
# ---- 摆杆 + 棘爪(右上)----
O2 = np.array([1.55, 1.15])
a_tip = np.radians(40)
tip = np.array([R * np.cos(a_tip), R * np.sin(a_tip)])
d = tip - O2
ang = np.arctan2(d[1], d[0])
dirv = np.array([np.cos(ang), np.sin(ang)])
handle = O2 - dirv * 0.86
ax.plot([handle[0], O2[0]], [handle[1], O2[1]], color=C_BLUE, lw=5.5,
solid_capstyle="round", zorder=2)
ax.plot([O2[0], tip[0] + 0.10 * dirv[0]],
[O2[1], tip[1] + 0.10 * dirv[1]], color=C_BLUE, lw=5.5,
solid_capstyle="round", zorder=2)
pawl(ax, tip, ang, L=0.60, w=0.15, fc="#cfe0f2", color=C_BLUE)
pivot(ax, O2, 0.085, C_BLUE)
# 往复摆动符号(双箭头圆弧,置于 O2 上方空档)
rot_arrow(ax, O2[0], O2[1], 0.40, 95, 25, color=C_RED, lw=1.7)
rot_arrow(ax, O2[0], O2[1], 0.40, 25, 95, color=C_RED, lw=1.7)
# 摆杆标注
ax.text(2.66, 1.02, "摆杆", fontsize=11.5, color=C_BLUE, ha="center",
zorder=9)
line(ax, (2.58, 1.12), (handle + np.array([0.04, 0.08])), color=C_BLUE,
lw=0.8, ls=(0, (3, 2)))
box(ax, 2.42, 2.12, 1.24, 0.40, "摆杆往复摆动", fc="#eef4fb", ec=C_BLUE,
fs=10)
arcx = O2 + 0.40 * np.array([np.cos(np.radians(60)),
np.sin(np.radians(60))])
line(ax, (1.92, 1.97), arcx + np.array([0.04, 0.05]), color=C_BLUE, lw=0.8,
ls=(0, (3, 2)))
# 棘爪标注
ax.text(1.66, 0.28, "棘爪", fontsize=11, color=C_BLUE, ha="center",
zorder=9)
line(ax, (1.48, 0.40), (1.10, 0.78), color=C_BLUE, lw=0.8, ls=(0, (3, 2)))
# ---- 止动爪(左上,固定支点)----
O3 = np.array([-1.45, 1.20])
a_t = np.radians(150)
tip2 = np.array([R * np.cos(a_t), R * np.sin(a_t)])
d2 = tip2 - O3
ang2 = np.arctan2(d2[1], d2[0])
pawl(ax, tip2, ang2, L=0.95, w=0.16, fc="#e2f0e4", color=C_GREEN)
pivot(ax, O3, 0.085, C_GREEN)
ax.plot([O3[0] - 0.36, O3[0] - 0.36], [O3[1] - 0.22, O3[1] + 0.22],
color=C_GREEN, lw=1.1, zorder=1)
for yy in np.linspace(O3[1] - 0.22, O3[1] + 0.22, 6):
ax.plot([O3[0] - 0.36, O3[0] - 0.42], [yy, yy - 0.08], color=C_GREEN,
lw=0.9, zorder=1)
ax.text(-1.22, 1.88, "止动爪(固定支点)", fontsize=10.5, color=C_GREEN,
ha="center", zorder=9)
# ---- 棘轮转向 ----
rot_arrow(ax, 0, 0, 1.28, 200, 258, color=C_RED, lw=2.0)
ax.text(-1.76, -0.22, "棘轮转向", fontsize=10.5, color=C_RED, ha="left",
va="center", zorder=9)
note(ax, -2.55, -1.55,
"组成:摆杆、棘爪、棘轮、止动爪\n"
"原理:摆杆往复摆动 → 棘爪推动棘轮间歇转动;止动爪防止反转",
fs=10.5)
save(fig, "figM01_棘轮机构组成.png")
# =====================================================================
# figM02 棘轮机构的类型
# =====================================================================
def figM02():
fig, axes = grid(2, 2, 8.4, 6.4)
titles = ["(1) 外缘棘轮机构", "(2) 内缘棘轮机构",
"(3) 端面棘轮机构", "(4) 棘条棘轮机构"]
# (1) 外缘
ax = axes[0]
ax.set_xlim(-1.5, 1.5); ax.set_ylim(-1.4, 1.4)
P = ratchet_outline(10, 1.0, 0.87)
ax.add_patch(Polygon(P, closed=True, fc="#f5f7f9", ec=C_MAIN, lw=1.4))
ax.add_patch(Circle((0, 0), 0.16, fc="white", ec=C_MAIN, lw=1.0))
tip = np.array([np.cos(np.radians(40)), np.sin(np.radians(40))])
pawl(ax, tip, np.arctan2(tip[1] - 1.30, tip[0] - 1.30), L=0.75, w=0.14,
fc="#cfe0f2", color=C_BLUE)
ax.text(0, -1.24, "齿在圆盘外缘", fontsize=10, ha="center", color=C_GRAY)
# (2) 内缘
ax = axes[1]
ax.set_xlim(-1.5, 1.5); ax.set_ylim(-1.4, 1.4)
ax.add_patch(Circle((0, 0), 1.0, fc="#f5f7f9", ec=C_MAIN, lw=1.4))
ax.add_patch(Circle((0, 0), 0.86, fc="white", ec=C_MAIN, lw=1.4))
for a in np.linspace(0, 2 * np.pi, 12, endpoint=False):
base = 0.86 * np.array([np.cos(a), np.sin(a)])
tp = 1.0 * np.array([np.cos(a), np.sin(a)])
n = np.array([-np.sin(a), np.cos(a)]) * 0.055
ax.add_patch(Polygon([base + n, tp, base - n], closed=True,
fc="#f5f7f9", ec=C_MAIN, lw=1.0, zorder=2))
tip = np.array([0.86 * np.cos(np.radians(150)),
0.86 * np.sin(np.radians(150))])
pawl(ax, tip, np.arctan2(tip[1] - 0.6, tip[0] - 0.6), L=0.68, w=0.14,
fc="#cfe0f2", color=C_BLUE)
ax.text(0, -1.24, "齿在圆环内缘", fontsize=10, ha="center", color=C_GRAY)
# (3) 端面
ax = axes[2]
ax.set_xlim(-1.5, 1.5); ax.set_ylim(-1.4, 1.4)
ax.add_patch(Ellipse((0, 0), 1.9, 1.5, fc="#f5f7f9", ec=C_MAIN, lw=1.4))
for a in np.linspace(0, 2 * np.pi, 14, endpoint=False):
r_ = np.array([np.cos(a), np.sin(a) * 0.79])
n = np.array([-np.sin(a), np.cos(a) * 0.79])
base = 0.90 * r_
tp = 0.68 * r_
ax.add_patch(Polygon([base + n * 0.05, tp, base - n * 0.05],
closed=True, fc="#f5f7f9", ec=C_MAIN, lw=0.9,
zorder=2))
ax.add_patch(Circle((0, 0), 0.14, fc="white", ec=C_MAIN, lw=1.0, zorder=3))
ax.text(0, -1.24, "齿在圆盘端面(俯视)", fontsize=10, ha="center",
color=C_GRAY)
# (4) 棘条
ax = axes[3]
ax.set_xlim(-1.5, 1.5); ax.set_ylim(-1.4, 1.4)
pts = [(-1.15, -0.55)]
for k in range(13):
x0 = -1.15 + k * 0.177
pts.append((x0, -0.10))
pts.append((x0 + 0.177 * 0.55, 0.30))
pts.append((x0 + 0.177, -0.10))
pts += [(1.15, -0.10), (1.15, -0.55)]
ax.add_patch(Polygon(pts, closed=True, fc="#f5f7f9", ec=C_MAIN, lw=1.4))
tip = np.array([0.16, 0.30])
pawl(ax, tip, np.radians(118), L=0.70, w=0.14, fc="#cfe0f2", color=C_BLUE)
arrow(ax, (0.90, -1.00), (0.25, -1.00), color=C_RED, lw=1.8)
ax.text(1.02, -1.00, "移动", fontsize=10, color=C_RED, va="center")
ax.text(0, -1.32, "矩形齿条(长行程)", fontsize=10, ha="center",
color=C_GRAY)
for ax, t in zip(axes, titles):
ax.set_title(t, fontsize=12, color=C_MAIN, pad=6)
fig.tight_layout()
save(fig, "figM02_棘轮机构类型.png")
# =====================================================================
# figM03 棘爪受力与齿偏角
# =====================================================================
def figM03():
fig, ax = new_ax(8.6, 6.6, (-1.10, 4.70), (-1.75, 3.85))
O1 = np.array([0.0, 0.0])
R = 1.0
A = np.array([0.0, R]) # 齿面接触点
al = np.radians(20)
f = np.array([np.sin(al), -np.cos(al)]) # 齿面方向(向下、微右)
nrm = np.array([np.cos(al), np.sin(al)]) # 齿面法线(向右上)
# 中间齿
tooth = [A + f * 0.02,
A + f * 0.62,
A + f * 0.62 - nrm * 0.55,
A - nrm * 0.40]
ax.add_patch(Polygon(tooth, closed=True, fc="#f2f4f6", ec=C_MAIN, lw=1.5,
zorder=3))
# 左右邻齿(局部展开示意)
for k in (-1, 1):
A2 = np.array([k * 0.98, R - 0.05])
f2 = np.array([k * np.sin(al), -np.cos(al)])
n2 = np.array([k * np.cos(al), np.sin(al)])
ax.add_patch(Polygon([A2 + f2 * 0.02, A2 + f2 * 0.62,
A2 + f2 * 0.62 - n2 * 0.55, A2 - n2 * 0.40],
closed=True, fc="#f2f4f6", ec=C_MAIN, lw=1.2,
zorder=2))
# 齿顶参考线
ax.plot([-0.95, 3.45], [-1.20, -1.20], color=C_MAIN, lw=1.2, zorder=1)
ax.text(0.05, -1.47, "棘轮(局部展开)", fontsize=10.5, color=C_GRAY)
# ---- 棘爪:O1A ⊥ AO2 ----
O2 = np.array([2.75, R])
d = A - O2
ang = np.arctan2(d[1], d[0])
pawl(ax, A, ang, L=2.45, w=0.20, fc="#cfe0f2", color=C_BLUE)
pivot(ax, O2, 0.09, C_BLUE)
ax.text(O2[0] + 0.14, O2[1] - 0.34, r"$O_2$(棘爪轴)", fontsize=10.5,
color=C_BLUE, ha="left", va="center")
# 径向线 O1A 与直角标记
line(ax, O1, A, color=C_GRAY, lw=1.0, ls=(0, (5, 3)))
ax.plot([0], [0], marker="+", ms=10, color=C_MAIN, zorder=5)
ax.text(-0.14, -0.14, r"$O_1$", fontsize=10.5, color=C_MAIN, ha="right",
va="top")
ax.add_patch(Rectangle((0.0, R - 0.20), 0.20, 0.20, fc="none",
ec=C_GRAY, lw=0.9, zorder=5))
ax.plot([A[0]], [A[1]], marker="o", ms=5.5, color=C_RED, zorder=6)
ax.text(A[0] - 0.10, A[1] + 0.16, "A", fontsize=11, color=C_RED,
ha="right")
# 齿偏角 α
aa = np.linspace(-np.pi / 2, -np.pi / 2 + al, 40)
ax.plot(A[0] + 0.95 * np.cos(aa), A[1] + 0.95 * np.sin(aa),
color=C_ORANGE, lw=1.5, zorder=6)
ax.text(A[0] + 0.46, A[1] - 0.44, r"$\alpha$", fontsize=13,
color=C_ORANGE, zorder=9)
# 力矢:FN(法向)、Ff(齿面方向)
F0 = A + nrm * 0.06
FN = F0 + nrm * 1.02
arrow(ax, F0, FN, color=C_RED, lw=2.2)
ax.text(FN[0] + 0.10, FN[1] + 0.02, r"$F_N$(正压力)", fontsize=10.5,
color=C_RED)
Ff0 = A + f * 0.06
Ff = Ff0 + f * 0.90
arrow(ax, Ff0, Ff, color=C_GREEN, lw=2.2)
ax.text(Ff[0] + 0.14, Ff[1] - 0.10, r"$F_f$(摩擦力)", fontsize=10.5,
color=C_GREEN)
line(ax, A, A + f * 1.15, color=C_GREEN, lw=1.0, ls=(0, (4, 3)))
line(ax, A, A + nrm * 1.30, color=C_RED, lw=1.0, ls=(0, (4, 3)))
# 标题与两处结论框
ax.text(-1.05, 3.78, "棘爪自动滑入齿槽的条件", fontsize=13,
color=C_BLUE, ha="left", va="top")
note(ax, -1.05, 3.32,
"两力对棘爪轴 $O_2$ 的力矩须满足\n"
"$M_{F_N}>M_{F_f}$ \n"
"\u2192 $F_N\\sin\\alpha\\cdot L>F_f\\cos\\alpha\\cdot L$ \n"
"\u2192 $\\tan\\alpha>f$ ,即 $\\alpha>\\varphi$ \n"
"取 $f=0.2$ 时 $\\varphi=11^\\circ 30^{\\prime}$ ,通常取 $\\alpha=20^\\circ$ ",
fs=10.5)
note(ax, 2.20, 3.32,
"轴心布置: $\\angle O_1AO_2=90^\\circ$ \n"
"\u2192 传递相同转矩时棘爪受力最小",
fs=10.5, fc="#fff8ec", ec=C_ORANGE)
save(fig, "figM03_棘爪受力与齿偏角.png")
# =====================================================================
# figM04 槽轮机构组成
# =====================================================================
def figM04():
fig, ax = new_ax(8.2, 6.6, (-1.62, 2.62), (-2.15, 1.65))
L = 1.0
P, g = geneva_wheel(z=4, L=L, b=0.09, r_inn=0.36)
ax.add_patch(Polygon(P, closed=True, fc="#f5f7f9", ec=C_MAIN, lw=1.5,
zorder=3))
ax.add_patch(Circle((0, 0), 0.11, fc="white", ec=C_MAIN, lw=1.1, zorder=4))
pivot(ax, (0, 0), 0.045)
ax.text(0.0, -0.30, r"$O_2$", fontsize=10.5, color=C_MAIN, ha="center",
zorder=9)
# ---- 拨盘:凸锁止弧(半径 r0)+ 圆销轨迹(虚线,半径 R)----
O1 = np.array([L, 0.0])
ax.add_patch(Circle(O1, g["r0"], fc="#e8eef6", ec=C_BLUE, lw=1.5,
zorder=4))
ax.add_patch(Circle(O1, g["R"], fc="none", ec=C_BLUE, lw=0.9,
ls=(0, (4, 3)), zorder=2))
ax.plot(*arc(O1[0], O1[1], g["r0"] + 0.006, 150, 210), color=C_ORANGE,
lw=2.8, zorder=5)
pivot(ax, O1, 0.045, C_BLUE)
ax.text(O1[0] + 0.40, O1[1] - 0.44, r"$O_1$", fontsize=10.5, color=C_BLUE,
ha="left", va="center", zorder=9)
# 曲柄 + 圆销
a_pin = np.radians(138)
pin = O1 + g["R"] * np.array([np.cos(a_pin), np.sin(a_pin)])
ax.plot([O1[0], pin[0]], [O1[1], pin[1]], color=C_BLUE, lw=5.0,
solid_capstyle="round", zorder=6)
ax.add_patch(Circle(pin, g["r_pin"], fc=C_RED, ec=C_RED, lw=1.0, zorder=8))
rot_arrow(ax, O1[0], O1[1], 0.28, 250, 340, color=C_RED, lw=1.8)
# ---- 标注 ----
ax.text(-1.58, 0.88, "槽轮", fontsize=11.5, color=C_MAIN, ha="left",
va="center", zorder=9)
line(ax, (-1.02, 0.84), (-0.40, 0.28), color=C_MAIN, lw=0.8,
ls=(0, (3, 2)))
ax.text(-1.34, 1.42, "凹锁止弧", fontsize=10.5, color=C_ORANGE, ha="left",
va="center", zorder=9)
line(ax, (-0.76, 1.36), (-0.08, 0.70), color=C_ORANGE, lw=0.8,
ls=(0, (3, 2)))
ax.text(0.98, 1.48, "拨盘(连续回转)", fontsize=11, color=C_BLUE,
ha="center", va="center", zorder=9)
ax.text(1.74, 0.94, "圆销", fontsize=10.5, color=C_RED, ha="left",
va="center", zorder=9)
line(ax, (1.72, 0.88), (pin[0] + 0.13, pin[1] + 0.11), color=C_RED, lw=0.8,
ls=(0, (3, 2)))
ax.text(1.64, -1.08, "径向槽", fontsize=10.5, color=C_MAIN, ha="left",
va="center", zorder=9)
line(ax, (1.60, -1.02), (0.44, -0.46), color=C_MAIN, lw=0.8,
ls=(0, (3, 2)))
note(ax, -1.60, -1.36,
"组成:拨盘(带圆销)+ 槽轮\n"
"锁止弧:槽轮凹弧 + 拨盘凸弧 → 锁定;圆销入槽 → 槽轮转动\n"
"作用:连续回转 → 间歇转动",
fs=10.5)
save(fig, "figM04_槽轮机构组成.png")
# =====================================================================
# figM05 槽轮运动系数
# =====================================================================
def figM05():
fig, ax = plt.subplots(figsize=(8.0, 5.4))
z = np.linspace(3, 16, 600)
for n, c in ((1, C_BLUE), (2, C_GREEN), (3, C_ORANGE)):
tau = n * (0.5 - 1.0 / z)
m = tau < 1.0
ax.plot(z[m], tau[m], color=c, lw=2.0, label=f"$n={n}$ 个圆销")
ax.axhline(1.0, color=C_RED, ls="--", lw=1.2)
ax.text(15.7, 1.015, r"$\tau=1$ → 已无间歇运动特性", fontsize=10,
color=C_RED, ha="right")
ax.axvspan(2.6, 3.0, color="#f0f0f0", zorder=0)
ax.text(3.25, 0.075, r"$z>2$ → $z\geq 3$", fontsize=10.5, color=C_MAIN)
ax.plot([4], [0.5], "o", ms=7, color=C_PURPLE, zorder=6)
ax.annotate(r"$z=4,\ n=2$ : $\tau=0.5$" + "\n运动时间 = 静止时间",
xy=(4, 0.5), xytext=(6.1, 0.30), fontsize=10.5,
color=C_PURPLE,
arrowprops=dict(arrowstyle="->", color=C_PURPLE, lw=1.2))
ax.text(7.35, 0.615,
"内槽轮: $\\tau=1/2+1/z$ ,只宜单销\n"
"(外啮合 $\\tau<1$ ;内啮合 $\\tau>1/2$ )",
fontsize=10, color=C_ORANGE, ha="left", va="center",
bbox=dict(boxstyle="round,pad=0.35", fc="white", ec=C_ORANGE,
lw=0.9, alpha=0.95))
ax.set_xlabel("槽数 $z$", fontsize=12)
ax.set_ylabel(r"运动系数 $\tau=t_m/t$", fontsize=12)
ax.set_xlim(2.6, 16)
ax.set_ylim(0, 1.12)
ax.grid(alpha=0.25, lw=0.6)
ax.legend(fontsize=10.5, loc="lower right", frameon=False)
ax.set_title("槽轮机构运动系数(外啮合,$\\tau=n(1/2-1/z)$ ,须 $\\tau<1$)",
fontsize=12, color=C_MAIN, pad=10)
fig.tight_layout()
save(fig, "figM05_槽轮运动系数.png")
# =====================================================================
# figM06 凸轮式间歇运动机构
# =====================================================================
def figM06():
fig, ax = new_ax(8.2, 5.4, (-0.4, 6.4), (-0.7, 4.2))
# 圆柱凸轮(轴竖直)
x0, x1, y0, y1 = 0.6, 2.3, 0.45, 3.35
ax.add_patch(Rectangle((x0, y0), x1 - x0, y1 - y0, fc="#eef2f6",
ec="none", zorder=2))
ax.add_patch(Ellipse(((x0 + x1) / 2, y1), x1 - x0, 0.34, fc="#e3e9f0",
ec=C_MAIN, lw=1.2, zorder=3))
ax.add_patch(Ellipse(((x0 + x1) / 2, y0), x1 - x0, 0.34, fc="#dfe6ee",
ec=C_MAIN, lw=1.2, zorder=1))
ax.plot([x0, x0], [y0, y1], color=C_MAIN, lw=1.2, zorder=3)
ax.plot([x1, x1], [y0, y1], color=C_MAIN, lw=1.2, zorder=3)
yy = np.linspace(y0 + 0.25, y1 - 0.25, 200)
ph = (yy - y0) / (y1 - y0)
xs = (x0 + x1) / 2 + (x1 - x0) * 0.42 * np.tanh(3.2 * np.sin(2 * np.pi * ph))
ax.plot(xs, yy, color=C_BLUE, lw=2.4, zorder=4)
ax.plot((x0 + x1) - (xs - (x0 + x1) / 2), yy, color=C_BLUE, lw=1.0,
ls=(0, (3, 2)), zorder=3)
ax.text(1.45, 3.62, "圆柱凸轮(连续回转)", fontsize=11, color=C_BLUE,
ha="center")
ax.text(0.05, 1.90, "凸轮\n廓线", fontsize=10.5, color=C_BLUE, ha="left")
rot_arrow(ax, 1.45, 1.90, 0.16, 250, 350, color=C_RED, lw=1.7)
# 从动圆盘(水平盘,透视)+ 柱销
O = np.array([4.45, 2.05])
ax.add_patch(Ellipse(O, 3.30, 1.30, fc="#f5f7f9", ec=C_MAIN, lw=1.5,
zorder=3))
ax.add_patch(Ellipse(O, 0.70, 0.28, fc="white", ec=C_MAIN, lw=1.2,
zorder=5))
for a in np.linspace(0, 2 * np.pi, 8, endpoint=False):
pos = O + np.array([1.36 * np.cos(a), 0.535 * np.sin(a)])
ax.add_patch(Ellipse(pos, 0.28, 0.28, fc="#ffe6e6", ec=C_RED, lw=1.3,
zorder=6))
engage = O + np.array([1.36 * np.cos(np.radians(180)),
0.535 * np.sin(np.radians(180))])
line(ax, engage, (2.30, engage[1]), color=C_ORANGE, lw=1.0, ls=(0, (3, 2)))
ax.text(2.68, 3.06, "柱销(均布)", fontsize=10.5, color=C_ORANGE,
ha="left", va="center")
line(ax, (2.82, 2.96), (3.06, 2.26), color=C_ORANGE, lw=0.9,
ls=(0, (3, 2)))
ax.text(4.45, 3.52, "从动圆盘(间歇转动)", fontsize=11, color=C_MAIN,
ha="center")
rot_arrow(ax, 4.45, 2.05, 2.00, 30, 115, color=C_RED, lw=1.8)
rot_arrow(ax, 4.45, 2.05, 2.00, 210, 295, color=C_RED, lw=1.8)
note(ax, -0.35, -0.60,
"运动规律取决于凸轮廓线形状 → 可选规律以减小动载荷、避免冲击 → 适合高速、高精度分度转位\n"
"类型:圆柱凸轮式、蜗杆凸轮式 应用:制瓶机、包装机、拉链嵌齿、高速冲床、多色印刷机",
fs=10.0)
save(fig, "figM06_凸轮式间歇运动机构.png")
# =====================================================================
# figM07 不完全齿轮机构
# =====================================================================
def figM07():
fig, axes = plt.subplots(1, 2, figsize=(9.6, 4.4))
# (1) 外啮合不完全齿轮机构
ax = axes[0]
ax.set_aspect("equal"); ax.axis("off")
ax.set_xlim(-1.65, 1.75); ax.set_ylim(-1.35, 1.45)
r1, r2 = 0.40, 0.65
O1 = np.array([-0.50, 0.0]); O2 = np.array([0.55, 0.0])
ax.add_patch(Circle(O1, r1, fc="#e8eef6", ec=C_BLUE, lw=1.5, zorder=3))
ax.add_patch(Circle(O2, r2, fc="#f5f7f9", ec=C_MAIN, lw=1.5, zorder=3))
# 主动轮:2 个齿(朝向从动轮)
for a in np.radians([-14, 14]):
b0 = r1 * np.array([np.cos(a), np.sin(a)])
tpp = (r1 + 0.11) * np.array([np.cos(a), np.sin(a)])
n = np.array([-np.sin(a), np.cos(a)]) * 0.055
ax.add_patch(Polygon([b0 + n, tpp, b0 - n], closed=True,
fc="#cfe0f2", ec=C_BLUE, lw=1.1, zorder=4))
# 从动轮:4 个齿(朝向主动轮)
for a in np.radians([180 - 30, 180 - 10, 180 + 10, 180 + 30]):
b0 = r2 * np.array([np.cos(a), np.sin(a)])
tpp = (r2 - 0.13) * np.array([np.cos(a), np.sin(a)])
n = np.array([-np.sin(a), np.cos(a)]) * 0.055
ax.add_patch(Polygon([b0 + n, tpp, b0 - n], closed=True,
fc="#f5f7f9", ec=C_MAIN, lw=1.1, zorder=4))
# 锁止弧
a1 = np.linspace(np.radians(30), np.radians(330), 160)
ax.plot(O1[0] + r1 * np.cos(a1), O1[1] + r1 * np.sin(a1), color=C_ORANGE,
lw=2.6, zorder=5)
a2 = np.linspace(np.radians(196), np.radians(344), 80)
ax.plot(O2[0] + r2 * np.cos(a2), O2[1] + r2 * np.sin(a2), color=C_ORANGE,
lw=2.6, zorder=5)
pivot(ax, O1, 0.036, C_BLUE); pivot(ax, O2, 0.036, C_MAIN)
ax.text(O1[0], -0.80, "主动轮\n(只有 1~2 个齿)", fontsize=10, ha="center",
color=C_BLUE)
ax.text(O2[0] + 0.06, 0.98, "从动轮", fontsize=10.5, ha="center",
color=C_MAIN)
ax.text(0.02, 0.66, "锁止弧", fontsize=10, color=C_ORANGE, ha="center")
ax.set_title("(1) 外啮合不完全齿轮机构", fontsize=11.5, color=C_MAIN)
# (2) 运动时间 / 静止时间对比(时间条)
ax = axes[1]
ax.set_aspect("auto"); ax.axis("off")
ax.set_xlim(-0.2, 10.2); ax.set_ylim(0.0, 4.6)
x0, x1 = 1.0, 9.0 # 主动轮转一周
# 图例
ax.add_patch(Rectangle((0.55, 4.06), 0.45, 0.24, fc="#f5c4b3",
ec=C_ORANGE, lw=1.0))
ax.text(1.12, 4.18, "从动轮运动", fontsize=10, va="center", color=C_ORANGE)
ax.add_patch(Rectangle((3.55, 4.06), 0.45, 0.24, fc="#ededed",
ec=C_GRAY, lw=1.0))
ax.text(4.12, 4.18, "从动轮静止", fontsize=10, va="center", color=C_GRAY)
def tbar(y, tmove, title):
ax.add_patch(Rectangle((x0, y), tmove, 0.55, fc="#f5c4b3",
ec=C_ORANGE, lw=1.2, zorder=3))
ax.add_patch(Rectangle((x0 + tmove, y), (x1 - x0) - tmove, 0.55,
fc="#ededed", ec=C_GRAY, lw=1.2, zorder=3))
ax.text(x0 + tmove / 2, y + 0.275, "运动", fontsize=10.5, ha="center",
va="center", color="#a04000", zorder=4)
ax.text(x0 + tmove + ((x1 - x0) - tmove) / 2, y + 0.275, "静止",
fontsize=10.5, ha="center", va="center", color="#5f5f5f",
zorder=4)
ax.text(x0, y + 0.80, title, fontsize=11, ha="left", va="bottom",
color=C_MAIN)
tbar(2.35, 2.0, "① 主动轮上只有 1 个齿 → 运动时间短")
tbar(0.78, 4.0, "② 主动轮上有 2 个齿 → 运动时间为 ① 的两倍")
ax.annotate("", xy=(x1, 0.44), xytext=(x0, 0.44),
arrowprops=dict(arrowstyle="<->", color=C_MAIN, lw=1.1))
ax.text((x0 + x1) / 2, 0.14, "主动轮转一周(一个循环)", fontsize=10,
ha="center", va="center", color=C_GRAY)
ax.set_title("(2) 运动时间 / 静止时间之比可在很大范围内变化",
fontsize=11.5, color=C_MAIN)
fig.tight_layout()
save(fig, "figM07_不完全齿轮机构.png")
# =====================================================================
# figM08 螺旋机构运动分析
# =====================================================================
def _screw(ax, x0, x1, y, right=True):
ax.add_patch(Rectangle((x0, y - 0.085), x1 - x0, 0.17, fc="#eef2f6",
ec=C_MAIN, lw=1.3, zorder=3))
xs = np.arange(x0 + 0.07, x1 - 0.03, 0.11)
for xx in xs:
ax.plot([xx, xx + 0.055], [y - 0.085, y + 0.085], color=C_BLUE,
lw=1.0, zorder=4)
ax.plot([xx + 0.055, xx + 0.11], [y + 0.085, y - 0.085],
color=C_BLUE, lw=1.0, zorder=4)
def _hatch(ax, x, y, h=0.52, color=C_MAIN, sgn=-1):
ax.plot([x, x], [y - h / 2, y + h / 2], color=color, lw=1.6, zorder=6)
for k in range(7):
yy = y - h / 2 + k * h / 6
ax.plot([x, x + sgn * 0.11], [yy, yy - 0.075], color=color, lw=1.0,
zorder=6)
def figM08():
fig, axes = plt.subplots(2, 1, figsize=(8.4, 5.6))
y = 0.40
# (a) 差动螺旋:旋向相同
ax = axes[0]
ax.set_aspect("equal"); ax.axis("off")
ax.set_xlim(-0.35, 6.45); ax.set_ylim(-0.75, 1.05)
_screw(ax, 0.35, 6.05, y, right=True)
_hatch(ax, 1.35, y, 0.60, C_MAIN, -1)
ax.text(1.35, -0.36, "螺母 A(固定)", fontsize=10, ha="center",
color=C_MAIN)
ax.add_patch(Rectangle((3.55, y - 0.30), 0.62, 0.60, fc="none",
ec=C_GREEN, lw=1.8, zorder=5))
ax.text(3.86, -0.36, "螺母 2(可移动)", fontsize=10, ha="center",
color=C_GREEN)
ax.text(0.42, y + 0.30, "螺杆 1", fontsize=10.5, color=C_BLUE)
arrow(ax, (1.30, 0.86), (2.55, 0.86), color=C_RED, lw=1.8)
ax.text(2.60, 0.86, r"$s_1=\frac{l_A\varphi}{2\pi}$", fontsize=10.5,
color=C_RED, va="center")
arrow(ax, (3.86, 0.86), (5.10, 0.86), color=C_PURPLE, lw=1.8)
ax.text(5.15, 0.86, r"$s_2=-\frac{l_B\varphi}{2\pi}$", fontsize=10.5,
color=C_PURPLE, va="center")
ax.text(6.02, 0.02, "A、B 段旋向相同", fontsize=10, color=C_ORANGE,
ha="right", va="center")
box(ax, 3.20, -0.72, 5.90, 0.40,
r"差动螺旋: $s=\frac{(l_A-l_B)\varphi}{2\pi}$ ,当 $(l_A-l_B)$ 很小时 $s$ 很小 → 微动螺旋(千分尺、镗刀微调)",
fc="#fff8ec", ec=C_ORANGE, fs=10)
ax.set_title("(a) 差动螺旋机构(旋向相同)", fontsize=11.5, color=C_MAIN)
# (b) 复式螺旋:旋向相反
ax = axes[1]
ax.set_aspect("equal"); ax.axis("off")
ax.set_xlim(-0.35, 6.45); ax.set_ylim(-0.75, 1.05)
_screw(ax, 0.35, 6.05, y, right=True)
_screw(ax, 3.55, 6.05, y, right=False)
_hatch(ax, 1.35, y, 0.60, C_MAIN, -1)
ax.text(1.35, -0.36, "螺母 A(固定)", fontsize=10, ha="center",
color=C_MAIN)
ax.add_patch(Rectangle((3.55, y - 0.30), 0.62, 0.60, fc="none",
ec=C_GREEN, lw=1.8, zorder=5))
ax.text(3.86, -0.36, "螺母 2(可移动)", fontsize=10, ha="center",
color=C_GREEN)
ax.text(0.42, y + 0.30, "螺杆 1", fontsize=10.5, color=C_BLUE)
arrow(ax, (1.30, 0.86), (2.55, 0.86), color=C_RED, lw=1.8)
ax.text(2.60, 0.86, r"$s_1$", fontsize=10.5, color=C_RED, va="center")
arrow(ax, (3.86, 0.86), (5.10, 0.86), color=C_PURPLE, lw=1.8)
ax.text(5.15, 0.86, r"$s_2$", fontsize=10.5, color=C_PURPLE, va="center")
ax.text(6.02, 0.02, "A、B 段旋向相反", fontsize=10, color=C_ORANGE,
ha="right", va="center")
box(ax, 3.20, -0.72, 5.90, 0.40,
r"复式螺旋: $s=\frac{(l_A+l_B)\varphi}{2\pi}$ ,位移相加 → 快速靠近或离开(车辆、电杆拉线机构)",
fc="#eef4fb", ec=C_BLUE, fs=10)
ax.set_title("(b) 复式螺旋机构(旋向相反)", fontsize=11.5, color=C_MAIN)
fig.tight_layout()
save(fig, "figM08_螺旋机构运动分析.png")
# =====================================================================
# figM09 万向铰链机构
# =====================================================================
def figM09():
fig, axes = plt.subplots(1, 2, figsize=(9.6, 4.8))
# (a) 单万向
ax = axes[0]
ax.set_aspect("equal"); ax.axis("off")
ax.set_xlim(-1.35, 1.35); ax.set_ylim(-1.05, 1.40)
A = np.radians(30)
ax.plot([-1.15, 0.0], [0.0, 0.0], color=C_MAIN, lw=3.2,
solid_capstyle="round", zorder=3)
ax.plot([0.0, 1.00 * np.cos(A)], [0.0, 1.00 * np.sin(A)], color=C_MAIN,
lw=3.2, solid_capstyle="round", zorder=3)
ax.add_patch(Circle((0, 0), 0.10, fc="white", ec=C_MAIN, lw=1.4, zorder=5))
ax.plot([-0.17, 0.17], [0, 0], color=C_RED, lw=2.0, zorder=6)
ax.plot([0, 0], [-0.17, 0.17], color=C_RED, lw=2.0, zorder=6)
for ang in (np.radians(150), A + np.pi):
p = 0.30 * np.array([np.cos(ang), np.sin(ang)])
n = np.array([-np.sin(ang), np.cos(ang)]) * 0.13
q = p + np.array([np.cos(ang), np.sin(ang)]) * 0.10
ax.plot([p[0] + n[0], q[0] + n[0]], [p[1] + n[1], q[1] + n[1]],
color=C_MAIN, lw=2.2, zorder=5)
ax.plot([p[0] - n[0], q[0] - n[0]], [p[1] - n[1], q[1] - n[1]],
color=C_MAIN, lw=2.2, zorder=5)
aa = np.linspace(0, A, 60)
ax.plot(0.52 * np.cos(aa), 0.52 * np.sin(aa), color=C_ORANGE, lw=1.5)
ax.text(0.60, 0.10, r"$\alpha$", fontsize=13, color=C_ORANGE)
ax.text(-1.05, 0.40, "轴 1", fontsize=11, color=C_MAIN)
ax.text(0.86, 0.60, "轴 2", fontsize=11, color=C_MAIN)
ax.text(0.06, -0.30, "十字轴", fontsize=10, color=C_RED)
rot_arrow(ax, -0.78, 0.0, 0.26, 110, 250, color=C_RED, lw=1.6, head=0.12)
ax.text(-1.08, -0.62, r"$\omega_1$", fontsize=11.5, color=C_RED)
note(ax, -1.32, -0.86,
r"$v_{A1}=v_{A2}$ → $\omega_1=\cos\alpha\cdot\omega_2'$ → $\omega_2'>\omega_1$" "\n"
r"位置 II 同理得 $\omega_2''=\omega_1\cos\alpha<\omega_1$" "\n"
r"→ $\omega_1\cos\alpha\leq\omega_2\leq\frac{\omega_1}{\cos\alpha}$",
fs=10.0)
ax.set_title("(a) 单万向铰链机构:平均传动比为 1,瞬时传动比变化",
fontsize=11.5, color=C_MAIN)
# (b) 双万向
ax = axes[1]
ax.set_aspect("equal"); ax.axis("off")
ax.set_xlim(-0.30, 3.10); ax.set_ylim(-0.78, 1.95)
A = np.radians(25)
p0 = np.array([0.00, 0.90]); p1 = np.array([1.00, 0.90])
p2 = p1 + 0.70 * np.array([np.cos(-A), np.sin(-A)])
p3 = p2 + np.array([0.95, 0.0])
ax.plot([p0[0] - 0.20, p0[0]], [p0[1], p0[1]], color=C_MAIN, lw=3.0,
solid_capstyle="round")
ax.plot([p0[0], p1[0]], [p0[1], p1[1]], color=C_MAIN, lw=3.0,
solid_capstyle="round")
ax.plot([p1[0], p2[0]], [p1[1], p2[1]], color=C_MAIN, lw=3.0,
solid_capstyle="round")
ax.plot([p2[0], p3[0]], [p2[1], p3[1]], color=C_MAIN, lw=3.0,
solid_capstyle="round")
for P in (p1, p2):
ax.add_patch(Circle(P, 0.085, fc="white", ec=C_MAIN, lw=1.4, zorder=6))
ax.plot([P[0] - 0.14, P[0] + 0.14], [P[1], P[1]], color=C_RED, lw=1.7,
zorder=7)
ax.plot([P[0], P[0]], [P[1] - 0.14, P[1] + 0.14], color=C_RED, lw=1.7,
zorder=7)
ax.text(-0.24, 1.10, "主动轴", fontsize=10.5, color=C_MAIN)
ax.text(1.44, 0.34, "中间轴", fontsize=10.5, color=C_MAIN, ha="center")
ax.text(2.30, 0.82, "从动轴", fontsize=10.5, color=C_MAIN, ha="center")
# 夹角 α(两处)
aa = np.linspace(-A, 0, 40)
ax.plot(p1[0] + 0.42 * np.cos(aa), p1[1] + 0.42 * np.sin(aa),
color=C_ORANGE, lw=1.4)
ax.text(p1[0] + 0.30, p1[1] + 0.18, r"$\alpha$", fontsize=12,
color=C_ORANGE)
ax.plot(p2[0] + 0.42 * np.cos(aa), p2[1] + 0.42 * np.sin(aa),
color=C_ORANGE, lw=1.4)
ax.text(p2[0] + 0.46, p2[1] - 0.24, r"$\alpha$", fontsize=12,
color=C_ORANGE)
note(ax, -0.28, 0.10,
"安装三条件:\n"
"① 主动、从动、中间三轴共面\n"
"② 主动轴、从动轴与中间轴的夹角相等\n"
"③ 中间轴两端的叉面在同一平面内",
fs=10.0, fc="#fff8ec", ec=C_ORANGE)
ax.set_title("(b) 双万向铰链机构:消除从动轴变速转动",
fontsize=11.5, color=C_MAIN)
fig.tight_layout()
save(fig, "figM09_万向铰链机构.png")
# =====================================================================
if __name__ == "__main__":
for f in (figM01, figM02, figM03, figM04, figM05,
figM06, figM07, figM08, figM09):
f()
print("全部完成")