1875 行
108 KiB
Python
1875 行
108 KiB
Python
# -*- coding: utf-8 -*-
|
||
u"""R2 底板 PCB 布线（M5，**4 层**，D15）。
|
||
|
||
# ⛔ 计算只在服务器上跑：.claude/r2/remote_route.ps1（它会带 DCDC_ROUTE_SERVER=1 --offline --replan）
|
||
/c/Python314/python .claude/r2/route_base.py # 读缓存 + 报告（本机可跑）
|
||
/c/Python314/python .claude/r2/route_base.py --push # 下发导线 + 过孔（本机）
|
||
/c/Python314/python .claude/r2/route_base.py --clear # 清掉全部布线（本机）
|
||
/c/Python314/python .claude/r2/route_base.py --snapshot-vias
|
||
|
||
2 层版（底层过路费 / D± 构造 / 12V 干道 / 3V3 槽墙 / 车道）整份在 `archive_base2L/route_base.py`。
|
||
**引擎仍是刀片那份 `router.py`**（0.25 网格 + 8 邻接 A*，L1/L4 两层可布、内层做平面），这里只换板级常量、加底板的障碍、写主流程。
|
||
|
||
## 叠层与分工（D15）
|
||
|
||
| 层 | 内容 | 布线器怎么看 |
|
||
|---|---|---|
|
||
| L1 | 5 个插槽 + 西侧 `+12V` 大铜（`pcb_base.l1_12v_rects`）| 可布；12V 大铜**只挡导线**（过孔可以落进去，铺铜自己挖反焊盘）|
|
||
| L2/L3 | GND 平面 | 不布线；GND 焊盘各打一个过孔下来 |
|
||
| L4 | 其余 133 件 | 主力布线层 |
|
||
|
||
## 主流程（`plan_all`）
|
||
|
||
1. **Kelvin**：`U13.10→Rs6.1`、`U13.9→Rs6.2` 各一条 0.3 专线，最先布。就近扎进平面的话，
|
||
INA226 量到的是「分流电阻 + 一段铜箔」的压降，读数随铜温漂，而 DRC / 连通性全过。
|
||
2. **9 A 上 L1**：`Rs6.2` 西侧一块 L4 `+12V` 铜（`V12_PATCH`）+ 15 个过孔，落进 L1 大铜。
|
||
3. **D± 七对**：USB1~5 按构造画（`dp_construct`，每根 1 个孔），U32 北沿 5/10/13/19 脚先按构造画
|
||
（`u32_north`）；上行 / USB6 从西侧孔起步交给 A*（DP 先、DM 贴着 DP，`HUG_PEN`）。
|
||
2026-09-11 起 Hub 走 strap 模式、口 1~3 片内对调，北去三对与槽上「D+ 在西」同序，**不再掉头**。
|
||
每处换层旁补一颗 GND 回流孔（`dp_return_vias`），每根 ≤ 4 孔（`dp_via_limit`，超了记未完成）。
|
||
3a. **只走 L4 的敏感网**（`NOVIA_NETS`）：晶振 / RBIAS / VDD18PLL / VDD18 / 两颗 Buck 的 FB / Kelvin，A* 不许打孔。
|
||
4. **平面网扇出**：每只 GND 贴片焊盘一个过孔（通孔焊盘本来就穿到内层，跳过）；
|
||
两边都 ≥ `EP_MIN` 的 GND 焊盘（U32 散热盘 / 插槽外壳盘 / DAC 底盘 / 模组底盘）在焊盘里打孔阵；
|
||
每只 L4 的 `+12V` 焊盘一个过孔，**必须落在 L1 12V 主块里**。
|
||
5. 其余：直连 + `router.route_groups` 按线宽分档 A*；`--repair` 拆线重布。
|
||
"""
|
||
import io
|
||
import json
|
||
import math
|
||
import os
|
||
import sys
|
||
|
||
# `--hash-seed N`：固定字符串哈希（只对 CPython 有意义；PyPy 按插入序遍历，结果与种子无关）。
|
||
if '--hash-seed' in sys.argv:
|
||
_seed = sys.argv[sys.argv.index('--hash-seed') + 1]
|
||
if os.environ.get('PYTHONHASHSEED') != _seed:
|
||
os.execve(sys.executable, [sys.executable] + sys.argv,
|
||
dict(os.environ, PYTHONHASHSEED=_seed))
|
||
|
||
sys.stdout.reconfigure(encoding='utf-8')
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
sys.path.insert(0, os.path.dirname(HERE))
|
||
sys.path.insert(0, HERE)
|
||
import pcb_base as B # noqa: E402
|
||
import router as RT # noqa: E402
|
||
import rules_base as RB # noqa: E402
|
||
|
||
# 用户明确要求所有布线运算都放到 10.5.5.13。快照、缓存报告和下发仍可在本机做，
|
||
# 但任何会启动 A* 的入口必须由 remote_route.ps1 在服务器上显式解锁。
|
||
_COMPUTE_FLAGS = ('--replan', '--dp-only')
|
||
if any(flag in sys.argv for flag in _COMPUTE_FLAGS) and os.environ.get('DCDC_ROUTE_SERVER') != '1':
|
||
sys.exit(u'!! 布线运算禁止在本机执行；请使用 .claude/r2/remote_route.ps1（服务器 10.5.5.13）')
|
||
|
||
# ── 把 router 的板级常量换成底板的 ────────────────────────────────────────
|
||
# `--grid G`：布线网格（默认 0.25）。规则 0.15 / 0.15 的最小线距是 0.3，0.25 网格只能按 0.5 一道排，
|
||
# 通道容量浪费约四成（0.5 / 0.65 间距的芯片周围尤其吃亏）。0.125 每轮慢 4~8 倍，只配顺序布线。
|
||
if '--grid' in sys.argv:
|
||
RT.G = float(sys.argv[sys.argv.index('--grid') + 1])
|
||
RT.B = B
|
||
RT.PCB = B.PCB
|
||
RT.NX = int(round(B.BW / RT.G)) + 1
|
||
RT.NY = int(round(B.BH / RT.G)) + 1
|
||
RT.PADS = os.path.join(HERE, '_base_pads.json')
|
||
RT.FINGER_KEEP_Y = 0.0 # 底板没有金手指区
|
||
RT.KELVIN = [] # Kelvin 在这里自己布（router 那份只在它自己的 plan_all 里用）
|
||
RT.KELVIN_PADS = set()
|
||
RT.CLR = 0.16 # 规则 0.15（四层，同刀片），留一点给网格吸附
|
||
if '--old-viamap' in sys.argv: # 对照：route_net 途中封过孔图用 2026-09-11 以前的旧口径
|
||
RT.VIA_MAP_FIX = False
|
||
if '--old-stub' in sys.argv: # 对照：route_net 途中引出脚占位用旧行为（主图 g 挑形状，和真正发线的 gt 不一致）
|
||
RT.STUB_SAME_GRID = False
|
||
if '--via-launch' in sys.argv: # 坐在孔上的落点孔心两层都算出口（第 29 轮：影子孔 59 → 25，但断开 29 → 32，默认关）
|
||
RT.VIA_LAUNCH_BOTH = True
|
||
RT.W_DEFAULT = 0.15
|
||
RT.EDGE_CLR = 0.4
|
||
# ⭐ 每层优选方向（2026-09-10 用户定）：**插槽面 L1 顺槽长走（x，'h'）、器件面 L4 横穿槽阵走（y，'v'）**，
|
||
# 逆向每格代价 ×2（软偏好：出脚、绕焊盘这种一两毫米的逆向照样走得通）。
|
||
# 以前这里是 `{}`（八方向同价），理由是「D± 全是南北向」—— 现在七对 D± 全按构造画、不走 A*，理由不成立。
|
||
# 几何上也顺：L1 x 28~70 被五排 1 mm 针挡死、x<35 是 12V 大铜，南北贯通车道只剩 x 70~74；
|
||
# 横穿槽阵的长线本来就在 L4 槽体底下走。`--no-dir` 退回八方向同价（对照用）。
|
||
if '--no-dir' in sys.argv:
|
||
RT.LAYER_DIR = {}
|
||
else:
|
||
RT.LAYER_DIR = {2: 'v', 1: 'h'}
|
||
RT.CROSS_COST = 2.0
|
||
# 靠平面成网：焊盘各自一个过孔，铜在几何上本来就是分开的（+12V → L1 大铜）。
|
||
# ⚠ +3V3 2026-09-10 深夜起回到布线网（L2 改整层 GND），不许再在这里 —— 否则它布断了连通性检查也不报
|
||
RT.ISLAND_NETS = ('+12V',)
|
||
CACHE = os.path.join(HERE, '_base_routes.json')
|
||
CACHE_SCHEMA = 8 # v8：4 层（D15）。旧的 2 层缓存（v7）必须被拒
|
||
BOARD_VIAS = os.path.join(HERE, '_base_board_vias.json')
|
||
ONBOARD = os.path.join(HERE, '_base_routes.onboard.json') # 最近一次 --push 下发的那份缓存
|
||
PLACE_JSON = os.path.join(HERE, '_base_place.json')
|
||
|
||
# ⛔ router 里有刀片专用的 `J1` 特判（那边 J1 是金手指：不封顶、不排序、**连通性检查直接跳过**）。
|
||
# 底板的 J1 是取电口（D16 起是 USB-C，与 J23 同料；之前是 DC 座），照原样 VIN_RAW 的入口脚就永远不被检查 —— 断了也报「0 条没搞定」。
|
||
# ⇒ 载入焊盘时改名，布线结果里不含位号，下发不受影响。
|
||
J1_ALIAS = 'J1dc'
|
||
|
||
|
||
class _NoNotch(object):
|
||
u"""`build_grid` 要 `pcb_pour.notch_cut()`（刀片金手指防呆缺口）—— 底板没有。"""
|
||
|
||
@staticmethod
|
||
def notch_cut():
|
||
return (-10.0, -10.0, -9.0, -9.0)
|
||
|
||
|
||
RT.P = _NoNotch
|
||
|
||
|
||
def _rule_min(net, auto):
|
||
u"""线宽下限查底板自己的 `rules_base`（router 那份会去 import 刀片的 pcb_rules）。"""
|
||
cls = RB.NET_TRACK.get(net)
|
||
if net in DP_NETS:
|
||
return RB.DIFF['strokeWidthMin']
|
||
if cls is None:
|
||
return 0.15
|
||
return RB.TRACK_RULES[cls]['strokeWidthMin']
|
||
|
||
|
||
RT.rule_min = _rule_min
|
||
|
||
# ── 通孔焊盘（layer 12）──────────────────────────────────────────────────
|
||
# 刀片全贴片，router 一句 `if lay not in LAY: continue` 就把它们漏出占用图。拆成两条：
|
||
# L4 那条可布（器件在背面），L1 那条带后缀、只当障碍（同网的线仍可从上面过）。
|
||
TH_SUFFIX = '#t'
|
||
TH_GROW = 0.6 # J1/J23 的孔是长槽，槽比焊盘大
|
||
# ⛔ **只有长槽件才放大 0.6**（2026-09-12）。原来是所有通孔盘一律 +0.6，于是 2.54 间距的
|
||
# 排针 / 风扇座（圆盘 1.6）在占用图里变成 2.2 × 2.2，相邻两脚之间只剩 0.34 —— 而出口
|
||
# 要「半盘 1.10 + 线半宽 + 净距 = 1.33」才落得下第一格 ⇒ **中间那几只脚一根铜都出不来**。
|
||
# 症状是布线器报「J26.3 没布通 / 一根铜都没有」，看着像没地方走，其实是脚被自己虚胖的
|
||
# 邻盘封死；压线宽、拆线重布、换落位（扫了 500 个候选）全都救不回来。
|
||
TH_GROW_REFS = ('J1', J1_ALIAS, 'J23')
|
||
TH_GROW_SMALL = 0.0 # 圆通孔盘：铜盘本身就是障碍，不用再放
|
||
TH_KEYS = set()
|
||
|
||
|
||
def th_grow(ref):
|
||
return TH_GROW if ref in TH_GROW_REFS else TH_GROW_SMALL
|
||
|
||
|
||
def split_th(pads):
|
||
out = []
|
||
for p in pads:
|
||
if p[6] == 12:
|
||
TH_GROW_NOW = th_grow(p[0])
|
||
# ⛔ 用**改名之后**的位号（J1 → J1dc）。第一版记的是 J1，load_pads 随后改名，
|
||
# 于是 J1 的两只通孔地脚没被认成通孔，被当成贴片散热盘在孔里打了孔阵
|
||
# （DRC「钻孔到钻孔」4 条，J1_2 / J1_3）。
|
||
TH_KEYS.add((J1_ALIAS if p[0] == 'J1' else p[0], str(p[1])))
|
||
a = list(p); a[6] = 2; a[4] += TH_GROW_NOW; a[5] += TH_GROW_NOW
|
||
b = list(p); b[6] = 1; b[1] = str(p[1]) + TH_SUFFIX
|
||
b[4] += TH_GROW_NOW; b[5] += TH_GROW_NOW
|
||
out += [a, b]
|
||
else:
|
||
out.append(list(p))
|
||
return out
|
||
|
||
|
||
def load_pads():
|
||
# ⚠ 丢掉零尺寸的「幽灵焊盘」：多边形焊盘拆条时的残留（J23 的 A1B12 / A4B9 各有两块 0.30×0.00），
|
||
# 真焊盘另有一块。留着的话平面网扇出要给它们找落孔点、信号网要去接它们，全报失败。
|
||
pads = [p for p in split_th(RT.load_pads()) if p[4] >= 0.05 and p[5] >= 0.05]
|
||
for p in pads:
|
||
if p[0] == 'J1':
|
||
p[0] = J1_ALIAS
|
||
u20_remap(pads)
|
||
return pads
|
||
|
||
|
||
# ── 试算：U20（ESP32-S3-WROOM-1）引脚重分配（2026-09-11，用户选「引脚重分配」）──────────────
|
||
# 只改布线器读到的焊盘网名，**不改原理图**；结果只能看、不能下发（缓存记 `u20_remap`，`--push` 拒绝）。
|
||
# 病因：NTC1/NTC2 在北排东头（IO1/IO2）却要去南边（RT601 (85,26) / RT602 (19,8)），风扇那组在南排（IO4~7）却要去西北角 ——
|
||
# 两组方向全反，风扇线横穿全板成了南北墙（PROGRESS「U20 一簇诊断」）。
|
||
# 约束（a3_ctrl.py 的 GPIO 表）：NTC 必须 ADC1（IO1~IO10）；IO19/20 USB、IO43/44 UART0、IO0/3/45/46 strapping、IO35~37 留 R8 PSRAM —— 都不动。
|
||
# 模组脚 → IO：4=IO4 5=IO5 6=IO6 7=IO7 23=IO21 24=IO47 25=IO48 38=IO2 39=IO1。
|
||
U20_REMAPS = {
|
||
# A：NTC ↔ 风扇测速对调（IO4/IO5 也是 ADC1），风扇 PWM/EN 挪到西列北端两颗空脚，UP_VBUS_DET 挪到南排（它去南边）
|
||
'A': {'4': 'NTC1', '5': 'NTC2', '39': 'FAN_TACH_OUT', '38': 'FAN_TACH_IN',
|
||
'24': 'FAN_PWM', '25': 'FAN_EN', '6': 'UP_VBUS_DET', '7': '', '23': ''},
|
||
# A2：同 A，只是 FAN_PWM / FAN_EN 放 23 / 24（西列再靠南一格）
|
||
'A2': {'4': 'NTC1', '5': 'NTC2', '39': 'FAN_TACH_OUT', '38': 'FAN_TACH_IN',
|
||
'23': 'FAN_PWM', '24': 'FAN_EN', '6': 'UP_VBUS_DET', '7': '', '25': ''},
|
||
# B：第 30 轮 A 把 RXD0/TXD0 弄断了 —— 它们固定在北排 36/37（UART0）要北上 J33，A 的风扇测速在 38/39 西去正好横过。
|
||
# ⇒ 北排东头 38/39 空出，风扇整组 4 根集中到西列北段 22~25（IO14/IO21/IO47/IO48）往西北直出；
|
||
# 原来 22 脚的 PRSNT5#（去南边 J38.63）挪到空出来的南排 7 脚（IO7）。
|
||
'B': {'4': 'NTC1', '5': 'NTC2', '6': 'UP_VBUS_DET', '7': 'PRSNT5#',
|
||
'22': 'FAN_TACH_OUT', '23': 'FAN_TACH_IN', '24': 'FAN_PWM', '25': 'FAN_EN', '38': '', '39': ''},
|
||
}
|
||
|
||
|
||
def u20_remap_name():
|
||
return sys.argv[sys.argv.index('--u20-remap') + 1] if '--u20-remap' in sys.argv else None
|
||
|
||
|
||
def u20_remap(pads):
|
||
name = u20_remap_name()
|
||
if not name:
|
||
return
|
||
m = U20_REMAPS[name]
|
||
import collections
|
||
before = collections.Counter(p[7] for p in pads if p[0] == 'U20' and p[7])
|
||
for p in pads:
|
||
if p[0] == 'U20' and str(p[1]) in m:
|
||
p[7] = m[str(p[1])]
|
||
after = collections.Counter(p[7] for p in pads if p[0] == 'U20' and p[7])
|
||
if before != after:
|
||
raise RuntimeError(u'U20 重分配 %s 丢 / 多了网：%s' % (name, (before - after) + (after - before)))
|
||
print(u' ⚠ 试算：U20 引脚重分配 %s（原理图没改，结果不许下发）' % name)
|
||
|
||
|
||
def load_board_vias():
|
||
u"""读取板端既有过孔；`--offline` 时使用本地快照供计算服务器复现。"""
|
||
if '--offline' in sys.argv:
|
||
if not os.path.exists(BOARD_VIAS):
|
||
raise RuntimeError(u'离线计算缺少 _base_board_vias.json；先在 EDA 可达机器运行一次预检')
|
||
return [tuple(v) for v in json.load(io.open(BOARD_VIAS, encoding='utf-8'))]
|
||
vias = RT.load_vias()
|
||
# ⛔ 快照只留**既不归布线缓存、也不归缝合**的孔（2026-09-10）。`RT.load_vias()` 是板上全部过孔：
|
||
# 布线已下发之后再重算，旧的 604 个布线孔（其中一个就扎在插槽定位柱里）和 122 个缝合孔会被当成
|
||
# 固定障碍 —— 新布线绕着一堆马上要被 `--clear` 删掉的孔走。布线孔由新缓存重下，缝合孔 `pour_base --stitch` 重算。
|
||
import pour_base as PO
|
||
# ⚠ 按「板上那一版」认，不按当前缓存：2026-09-10 缓存已换成没下发的新结果，按它认的话板上 620 个旧布线孔全成了「固定障碍」
|
||
src = ONBOARD if os.path.exists(ONBOARD) else CACHE
|
||
mine = []
|
||
if os.path.exists(src):
|
||
mine = [v for v in json.load(io.open(src, encoding='utf-8')).get('vias', [])]
|
||
print(u'（按 %s 认布线孔）' % os.path.basename(src))
|
||
off, pitch = PO.INSET + 2.0, PO.STITCH_SUB # 子网格：天线周边加密孔也在上面（第 4 阶段）
|
||
|
||
def on_stitch(v):
|
||
return v[2] == 'GND' and all(abs((t - off) / pitch - round((t - off) / pitch)) < 1e-3 for t in v[:2])
|
||
|
||
n_mine = n_st = 0
|
||
keep = []
|
||
for v in vias:
|
||
# 0.2 而不是 0.01：USB3 掉头的 USB3_DM 孔在板上比缓存偏了 (−0.127, +0.127) = 正好一格 5 mil，
|
||
# 按 0.01 认不出来，就被当成固定障碍留下了。同网、0.2 以内的孔只可能是同一个。
|
||
if any(m[2] == v[2] and abs(m[0] - v[0]) < 0.2 and abs(m[1] - v[1]) < 0.2 for m in mine):
|
||
n_mine += 1
|
||
elif on_stitch(v):
|
||
n_st += 1
|
||
else:
|
||
keep.append(v)
|
||
print(u'板上过孔 %d = 布线缓存 %d + 缝合 %d + 其余 %d（只有「其余」交给布线当障碍）'
|
||
% (len(vias), n_mine, n_st, len(keep)))
|
||
io.open(BOARD_VIAS, 'w', encoding='utf-8').write(json.dumps(keep, ensure_ascii=False, indent=2))
|
||
return keep
|
||
|
||
|
||
# ── 线宽 ─────────────────────────────────────────────────────────────────
|
||
PAIRS = {name: (dp, dm) for name, dp, dm in RB.PAIRS}
|
||
DP_NETS = []
|
||
for _name, _dp, _dm in RB.PAIRS:
|
||
DP_NETS += [_dp, _dm]
|
||
DIFF_W = RB.DIFF['strokeWidthDefault'] # 0.28（L4 参考 L3 / L1 参考 L2，~90 Ω）
|
||
RT.WIDTH = {
|
||
# 9 A 由之后的铺铜 + 断面校核保证。⚠ D16 之后这是整板重布（plan_all）的起手宽；南带局部补线走
|
||
# d16_route.py 自己的线宽（0.4~0.5 —— 2.0 落不进 0402 和 U37 的 0.4 mm VIN 脚）
|
||
'VIN_RAW': 2.0, 'VIN_FUSED': 2.0, 'VIN_SW': 2.0,
|
||
'FAN_12V_SW': 0.8,
|
||
# +5V 只给每槽刀片上的负载开关（规则 PWR5V 下限 0.2）。0.6 的干线从槽针排里出不来 ——
|
||
# +3V3 改平面网那一轮，5 个槽的 10 只 5V 针全部没接上。
|
||
'+5V': 0.4, '+3V3': 0.4,
|
||
'+3V3_HUB': 0.3, # 要从 U32 北沿夹在 D± 中间的 5/10/13 脚出来，粗了出不来
|
||
}
|
||
for _n in DP_NETS:
|
||
RT.WIDTH[_n] = DIFF_W
|
||
RT.WIDTH_AUTO = {}
|
||
RT.NO_CAP = tuple(DP_NETS) + ('VIN_RAW', 'VIN_FUSED', 'VIN_SW', '+5V', '+3V3', '+3V3_HUB')
|
||
# ⭐ 2026-09-10 深夜用户拍板：L2 由整层 +3V3 改**整层 GND**（双地 —— L1 信号参考 L2 地、L4 参考 L3 地，
|
||
# 换层回流靠旁边的 GND 孔闭合；依据 Ott 叠层 / 乐鑫 ESP32-S3 指南 / TI SPRAAR7）。
|
||
# +3V3（47 只脚：15 只槽针每槽 ~3 mA、A3 16 只、A4M 8 只，合计 ≈0.5 A）重新成为**布线网**，宽 0.4。
|
||
# 上一次它是布线网时有二十来处没布通（PROGRESS），这回先按普通网布一轮看结果，不行再上构造干线。
|
||
# （更早那一版：「+3V3 是平面网，每脚一孔扎进 L2」—— 已作废。）
|
||
PLANE_NETS = ('GND', '+12V')
|
||
LATE_PLANE_NETS = ('GND',) # 布完信号之后才打孔的平面网（早打会封死 1 mm 针排里的信号脚）
|
||
# 诊断开关（2026-09-11，只在服务器对照实验用，结果别下发）：量化 +3V3 改布线网之后占了多少地盘。
|
||
# --3v3-plane：+3V3 当平面网，每只脚打一个孔（= L2 还是 +3V3 整层那时的做法）
|
||
# --3v3-skip ：+3V3 完全不布（上限）
|
||
if '--3v3-plane' in sys.argv:
|
||
PLANE_NETS = PLANE_NETS + ('+3V3',)
|
||
LATE_PLANE_NETS = LATE_PLANE_NETS + ('+3V3',)
|
||
|
||
# ── Kelvin 取样 ──────────────────────────────────────────────────────────
|
||
# ⚠ 2026-09-11 起 U13 的 IN± 对调接（A1-INPUT；R1 不变）：U13.10 在上、Rs6.2(+12V) 在北，
|
||
# U13.9 在下、Rs6.1(VIN_SW) 在南 —— 两条只走 L4 的 Kelvin 不再交叉。原来 IN− 为了绕开 IN+ 走了 37 mm，
|
||
# 把 U13 东列的 SDA / INA_ALERT 圈死。读数因此为负，固件 ina226_set_reversed(0x43) 取反。
|
||
KELVIN = [(('U13', '10'), ('Rs6', '2'), 0.3), # IN+ ← 分流电阻下游（+12V）
|
||
(('U13', '9'), ('Rs6', '1'), 0.3)] # IN− ← 分流电阻上游（VIN_SW）
|
||
KELVIN_W = 0.3
|
||
|
||
# ── 9 A 上 L1：Rs6.2 西侧那块 L4 铜 + 过孔阵 ────────────────────────────────
|
||
# 北边是泄放链（R9A/R9B 焊盘下沿 48.29），东边是 C4 / U13，只有西侧 x 5.3~10.8 空着。
|
||
# 铜块东端盖住 Rs6.2 焊盘（同网），过孔 5 × 3 = 15 个（0.3 孔 1 oz 每个 ~1 A 保守）。
|
||
V12_PATCH = (5.3, 44.4, 14.3, 48.05)
|
||
V12_VIA_X = (5.9, 7.0, 8.1, 9.2, 10.25)
|
||
V12_VIA_Y = (45.0, 46.1, 47.2)
|
||
|
||
|
||
def v12_vias():
|
||
return [(x, y) for x in V12_VIA_X for y in V12_VIA_Y]
|
||
|
||
|
||
# ── 入口链那一条（L4）：别的网收过路费，之后 9 A 的铜面要从这里铺 ─────────────
|
||
CHAIN_STRIP = (7.5, 0.5, 18.5, 48.0)
|
||
CHAIN_PEN = 4
|
||
CHAIN_NETS = ('VIN_RAW', 'VIN_FUSED', 'VIN_SW')
|
||
|
||
# ── D± 贴合 ──────────────────────────────────────────────────────────────
|
||
HUG_BAND = 0.9 # DP 铜外 0.9 mm 以内不收费（DM 中心距 0.5 就落在里面）
|
||
HUG_PAD = 1.5 # DM 自己的脚周围也不收费，好起步 / 收尾
|
||
HUG_PEN = 12
|
||
DP_PAD_PEN = 3 # 布 D± 时的焊盘过路费（默认 10 会让它们绕着满板焊盘蜿蜒）
|
||
# ⛔ 北去三对（USB1~3）必须**先**布。第一版先布 USB5/USB4（最长），A* 从 U32 北沿横着往西抄近路，
|
||
# 把 USB1~3 的出口整排封死（服务器首轮：三对全「没布通」）。先布北去的，它们的竖线就是一道墙，
|
||
# 南去的两对只能往东绕 —— 那正是摆位时给它们留的 DP_H 车道。
|
||
# ⚠ USB1 必须在 USB2 前面：两对都要往西绕开 USB3 的 U 形，USB2 先布就横着压过 USB1 的出口
|
||
# （第三轮：USB1 两只脚都「出不来」）。最西的先走、走得最远。
|
||
PAIR_ORDER = ['USB6', 'USBUP'] # USB1~5 全部按构造画（dp_construct）；这两对从 L1 的孔起步
|
||
|
||
# 最后一段才布的电源网（它们的脚在前两段一直收过路费）。
|
||
# ⛔ 第二轮是按线宽分档、宽的先布：+3V3 / +5V 的干线沿走廊边一铺，正好横在 U35 两排脚、
|
||
# U20 西排、风扇那一窝的出口上，于是几十条信号「没布通」。
|
||
# +3V3 自 2026-09-10 深夜起是普通布线网（L2 改整层 GND），和 +5V 一样在信号那一段一起布
|
||
# （最后布时通道早被占完，+5V 那次 10 只槽针全落空）
|
||
POWER_LATE = ('+3V3_HUB', 'FAN_12V_SW')
|
||
# 在 U32 本地网之后、普通信号之前单独先布的网（2026-09-11，第 22 轮）：
|
||
# U13 东列 2/5 脚都是 SCL、4 脚 SDA、3 脚 INA_ALERT 夹在中间。SCL 从芯片底下把 2/5 连起来（挡西），
|
||
# SDA 出脚就斜向东北（挡东）⇒ INA_ALERT 出不来。它是一对一的短网，先布占住东边那条道，SDA 多走半格就行。
|
||
# 2026-09-11 第 34 轮起加 RXD0：方案 B 落地后 RXD0（应急 UART）断 —— 它的扇出孔落在 U20 北排焊盘南侧，
|
||
# J33 在北 18 mm，按普通顺序轮到它时北边已被占满。先布它：离线断开 27 → 26、RXD0 通（再加 PRSNT3# / TXD0 都更差）。
|
||
EARLY_NETS = ('INA_ALERT', 'RXD0')
|
||
# `--early-add A,B`（试算）：再加几个网进「普通信号之前先布」那一段。
|
||
if '--early-add' in sys.argv:
|
||
EARLY_NETS = EARLY_NETS + tuple(sys.argv[sys.argv.index('--early-add') + 1].split(','))
|
||
|
||
# ── 平面网扇出 ────────────────────────────────────────────────────────────
|
||
EP_MIN = 1.2 # GND 焊盘两边都 ≥ 这个 ⇒ 焊盘里打孔（散热盘 / 外壳盘）
|
||
EP_PITCH = 1.2
|
||
EP_EDGE = 0.45 # 孔心离焊盘边
|
||
V12_LAND = 0.6 # +12V 过孔离 L1 主块边
|
||
|
||
|
||
def place_pos():
|
||
d = json.load(io.open(PLACE_JSON, encoding='utf-8'))
|
||
return {k: (v[0], v[1], v[2]) for k, v in d.items()}
|
||
|
||
|
||
# 封装自带的非金属化孔：五个插槽各两颗定位柱 Ø1.21（x 44.15 / 67.30，槽心线上）+ J23 两颗 Ø0.61。
|
||
# API 读不出来（skill §9u），`npth_base.py --write` 从 L2/L3 反焊盘反解。[x, y, 孔半径, 反焊盘半径]。
|
||
# 2026-09-10 以前没有它：USB1 D±、+5V、SCL3 等 12 个网直接从孔上走过去（DRC「挖槽区域 到 导线 0mil」）。
|
||
# 禁区按反焊盘半径（孔 + 实测铜面净距 0.353，比 DRC 要的 0.3 严）。缺文件直接报错 —— 没有它就会再压一次孔。
|
||
NPTH = json.load(io.open(os.path.join(HERE, '_base_npth.json'), encoding='utf-8'))
|
||
|
||
|
||
def keep_rects():
|
||
u"""所有铜层都不许有铜：天线净空 + 板框缺口（外扩板边净距）+ 封装自带的 NPTH。"""
|
||
import place_base as PL
|
||
ant = PL.antenna_keepout(PL.sizes(), place_pos())
|
||
n = B.notch_rect()
|
||
e = RT.EDGE_CLR
|
||
return ([ant, (n[0] - e, n[1] - e, n[2] + 1.0, n[3] + e)] +
|
||
[(h[0] - h[3], h[1] - h[3], h[0] + h[3], h[1] + h[3]) for h in NPTH])
|
||
|
||
|
||
_KEEP = [None]
|
||
_orig_build = RT.build_grid
|
||
_orig_pen = RT.pen_pads
|
||
|
||
|
||
def _build(pads, halfw, vias=()):
|
||
g = _orig_build(pads, halfw, vias)
|
||
_no_via_in_pad(g, pads)
|
||
extra = max(0.0, RT.VIA_D / 2.0 + RT.CLR - halfw)
|
||
# 只打导线图：过孔可以落进大铜。D16 窗口（pcb_base.PD_L1：CC 两根 + VIN_FUSED 小岛）先从 12V 里扣掉、
|
||
# 再按各自的网封 —— ⚠ router 的 _mark 在别的网已占的格子上写，会变成 255（谁都走不了），不能叠加
|
||
holes = [r for _n, r in B.PD_L1]
|
||
for r in B.l1_12v_rects():
|
||
for q in B.rect_minus((r[0] - halfw, r[1] - halfw, r[2] + halfw, r[3] + halfw), holes):
|
||
g.block_rect(1, q[0], q[1], q[2], q[3], net='+12V')
|
||
for n, r in B.PD_L1:
|
||
g.block_rect(1, r[0], r[1], r[2], r[3], net=n)
|
||
x0, y0, x1, y1 = V12_PATCH
|
||
g.block_both(2, x0 - halfw, y0 - halfw, x1 + halfw, y1 + halfw, extra, net='+12V')
|
||
if _KEEP[0] is None:
|
||
_KEEP[0] = keep_rects()
|
||
for r in _KEEP[0]:
|
||
for l in RT.LAY:
|
||
g.block_both(l, r[0] - halfw, r[1] - halfw, r[2] + halfw, r[3] + halfw, extra, net='#edge')
|
||
return g
|
||
|
||
|
||
# 还没打孔的 GND 贴片焊盘 + 后面阶段才布的网的焊盘：一律收过路费，给它们自己留出口。
|
||
GND_PEN_PADS = []
|
||
LATER_PEN_PADS = []
|
||
|
||
|
||
def _pen(g, pads, halfw):
|
||
_orig_pen(g, list(pads) + GND_PEN_PADS + LATER_PEN_PADS, halfw)
|
||
g.penalize(2, CHAIN_STRIP[0], CHAIN_STRIP[1], CHAIN_STRIP[2], CHAIN_STRIP[3], CHAIN_PEN)
|
||
|
||
|
||
# ⛔ **贴片焊盘里不许落过孔**（散热 / 外壳盘除外，它们的孔阵是 plane_vias 专门打的）。
|
||
# router 按「网」标归属，同网的过孔可以落进自己的焊盘 —— 插槽是手焊的，孔在焊盘里会吸锡；
|
||
# 0402 的盘上打孔也一样。第二轮已见 A* 把 D± 的孔打在槽针焊盘边上。
|
||
def _no_via_in_pad(g, pads):
|
||
k = g.nid('#pad')
|
||
r = RT.VIA_D / 2.0
|
||
for p in pads:
|
||
if p[6] not in RT.LAY or is_ep(p) or str(p[1]).endswith(TH_SUFFIX) or (p[0], str(p[1])) in TH_KEYS:
|
||
continue
|
||
# 只打焊盘所在那一层就够：过孔是通孔，free_via 两层都查
|
||
g._mark(g.ownv, p[6], p[2] - p[4] / 2 - r, p[3] - p[5] / 2 - r,
|
||
p[2] + p[4] / 2 + r, p[3] + p[5] / 2 + r, k, True)
|
||
|
||
|
||
RT.build_grid = _build
|
||
RT.pen_pads = _pen
|
||
|
||
# ── 12V 大铜底下三个区（L1 被 12V 占着，只能走 L4）：没有焊盘在这里的网，路过要加价 ─────────
|
||
# 第九轮：Buck 反馈分压（$2N72 / $2N70）、U13 的 I²C、风扇几个本地网「没布通」—— 它们一两毫米的路
|
||
# 被跨半块板的 +3V3 / 风扇信号 / I²C 总线从这里穿过去占了。
|
||
UNDER_12V_ZONES = ('A1', 'A2', 'A6')
|
||
UNDER_12V_PEN = 6
|
||
_orig_route_net = RT.route_net
|
||
|
||
|
||
def _route_net(g, net, pads_of_net, *a, **k):
|
||
for z in UNDER_12V_ZONES:
|
||
r = B.ZONES[z]
|
||
if not any(r[0] <= q[2] <= r[2] and r[1] <= q[3] <= r[3] for q in pads_of_net):
|
||
g.penalize(2, r[0], r[1], r[2], r[3], UNDER_12V_PEN)
|
||
return _orig_route_net(g, net, pads_of_net, *a, **k)
|
||
|
||
|
||
if '--zone-pen' in sys.argv:
|
||
RT.route_net = _route_net
|
||
|
||
|
||
# ── 小工具 ───────────────────────────────────────────────────────────────
|
||
# ── 敏感网只走 L4（2026-09-11 第 4 阶段，用户选定）─────────────────────────────
|
||
# 晶振 / RBIAS / VDD18PLL / VDD18、两颗 Buck 的 FB、INA226 的 Kelvin：换层 = 回流换参考面 + 一段孔的电感，
|
||
# 而这几个网都只有一两毫米。一律不许打孔：A* 的过孔代价抬到 1e9，路径里只要换层就作废（记为没布通，不偷偷放过）。
|
||
NOVIA_NAMED = ('XTAL1', 'XTAL2', 'RBIAS', 'VDD18PLL', 'VDD18')
|
||
NOVIA_PINS = (('U19', '4'), ('U30', '4')) # 两颗 Buck 的 FB 脚（SOT-23-6：4 = FB；U30 那边是自动网名）
|
||
NOVIA_NETS = set()
|
||
_orig_astar = RT.astar
|
||
|
||
|
||
def _astar_l4(g, starts, goals, net, halfw):
|
||
s2 = [s for s in starts if s[0] == 2]
|
||
g2 = [q for q in goals if q[0] == 2]
|
||
vc = RT.VIA_COST
|
||
RT.VIA_COST = 1e9
|
||
try:
|
||
path = _orig_astar(g, s2, g2, net, halfw)
|
||
finally:
|
||
RT.VIA_COST = vc
|
||
if path and any(a[0] != 2 for a in path):
|
||
return None
|
||
return path
|
||
|
||
|
||
def _astar(g, starts, goals, net, halfw):
|
||
if net in NOVIA_NETS:
|
||
return _astar_l4(g, starts, goals, net, halfw)
|
||
return _orig_astar(g, starts, goals, net, halfw)
|
||
|
||
|
||
RT.astar = _astar # router 内部按全局名调 astar，换掉模块属性即生效
|
||
|
||
# 诊断（只在服务器用）：`--dbg-nets A,B` —— 这些网在 route_net 里失败时，把那一刻的占用图原样存成 `_dbg_<网>.json`，
|
||
# 再用 `reach_audit.py --dbg-cmp` 和同一次运行的最终占用图逐格比：找「布线当时封着、最终图却是空的」格点。
|
||
# （2026-09-11 第 27 轮：EFUSE_EN4/5、UP_VBUS_DET 在最终图上重放布得通，布线当时却报没布通。）
|
||
DBG_NETS = set(sys.argv[sys.argv.index('--dbg-nets') + 1].split(',')) if '--dbg-nets' in sys.argv else set()
|
||
_orig_route_net = RT.route_net
|
||
|
||
|
||
def _route_net_dbg(g, net, pads_of_net, halfw, width, others_by_layer, log, gt=None, mutate=True):
|
||
n0 = len(log)
|
||
out = _orig_route_net(g, net, pads_of_net, halfw, width, others_by_layer, log, gt, mutate)
|
||
if net in DBG_NETS and len(log) > n0 and mutate:
|
||
import base64
|
||
b = lambda a: base64.b64encode(bytes(a)).decode('ascii') # noqa: E731
|
||
d = {'net': net, 'halfw': halfw, 'width': width, 'NX': RT.NX, 'NY': RT.NY, 'G': RT.G,
|
||
'ids': dict(g._id), 'logs': log[n0:], 'pads': [list(p) for p in pads_of_net],
|
||
'own1': b(g.own[1]), 'own2': b(g.own[2]), 'ownv1': b(g.ownv[1]), 'ownv2': b(g.ownv[2])}
|
||
json.dump(d, io.open(os.path.join(HERE, '_dbg_%s.json' % net.replace('#', '_')), 'w', encoding='utf-8'))
|
||
print(u' [dbg] %s 失败，占用图已存（%s）' % (net, u'；'.join(log[n0:])))
|
||
return out
|
||
|
||
|
||
if DBG_NETS:
|
||
RT.route_net = _route_net_dbg
|
||
|
||
|
||
def grid_now(pads, halfw, segs, vias, board_vias):
|
||
u"""按 halfw 建占用图并打进已布的铜；再建一张「引出脚口径」的图 gt。和 route_groups 同一套判据。"""
|
||
g = RT.build_grid(pads, halfw, board_vias)
|
||
# ⛔ 过孔图的口径（2026-09-11 修，和 build_grid 里焊盘 / 旧孔同一套）：
|
||
# 线：新孔中心离线心 ≥ VIA_D/2 + CLR + ww/2 ⇒ extra = VIA_D/2 + CLR − halfw。
|
||
# 原来减的是 (halfw + ww/2)，把这条线自己的半宽丢了 —— 0.4 的 +3V3 / +5V 线旁边 0.625 处照样落孔，
|
||
# 第 17 轮 DRC「线到孔 4.9 mil」15 条全是这个（细线也少 0.075，多半被网格取整盖住）。
|
||
# 孔：原来只 block_rect 进走线图、没进过孔图，free_via 看不见已放的孔 ——
|
||
# USB3 的 GND 回流孔就贴着 USB3_DM 构造孔落下（中心距 0.726，要 VIA_D + CLR = 0.76）。
|
||
for (l, a, b, c, d, ww, nn) in segs:
|
||
RT.block_track(g, l, a, b, c, d, halfw + ww / 2.0, nn,
|
||
extra=max(0.0, RT.VIA_D / 2.0 + RT.CLR - halfw), exact_v=True)
|
||
for (vx, vy, nn) in vias:
|
||
rv = RT.VIA_D / 2.0 + RT.CLR + halfw
|
||
ev = max(0.0, RT.VIA_D / 2.0 - halfw) # 过孔图总口径 = max(rv, VIA_D + CLR)
|
||
for l in RT.LAY:
|
||
g.block_both(l, vx - rv, vy - rv, vx + rv, vy + rv, ev, net=nn, exact_v=True)
|
||
# 过孔图用精确模式（孔只落在格点上）：保守取整会让细线旁 0.625 这种合法落孔点也没了
|
||
gt = RT.Grid()
|
||
sh = RT.W_DEFAULT / 2.0
|
||
for (l, a, b, c, d, ww, nn) in segs:
|
||
RT.block_track(gt, l, a, b, c, d, RT.CLR + sh + ww / 2.0, nn)
|
||
for (vx, vy, nn) in vias:
|
||
r = RT.VIA_D / 2.0 + RT.CLR + sh
|
||
for l in RT.LAY:
|
||
gt.block_rect(l, vx - r, vy - r, vx + r, vy + r, net=nn)
|
||
others = {1: [RT.pad_rect(p) for p in pads if p[6] == 1],
|
||
2: [RT.pad_rect(p) for p in pads if p[6] == 2]}
|
||
return g, gt, others
|
||
|
||
|
||
def route_one(net, ps, w, pads, segs, vias, board_vias, logs, pen_pads=(), hug=None, fence=()):
|
||
halfw = w / 2.0 + RT.CLR
|
||
g, gt, others = grid_now(pads, halfw, segs, vias, board_vias)
|
||
for (l, r) in fence: # 只对这一个网的禁区（导线图，按层）
|
||
g.block_rect(l, r[0], r[1], r[2], r[3], net='#fence')
|
||
RT.pen_pads(g, list(pen_pads), halfw)
|
||
if hug:
|
||
apply_hug(g, hug)
|
||
s, v, st = RT.route_net(g, net, ps, halfw, w, others, logs, gt)
|
||
out = list(s)
|
||
for (q, node, ww) in st:
|
||
out += RT.stub_emit(q, RT.wx(node[1]), RT.wy(node[2]),
|
||
[] if RT._is_launch(q) else others.get(q[6], []), ww / 2.0, ww, net, gt)
|
||
return out, list(v)
|
||
|
||
|
||
def apply_hug(g, band):
|
||
u"""band = {层: [矩形]}：矩形外的格点一律至少收 HUG_PEN。**在 pen_pads 之后调**（它会先清零）。"""
|
||
n = RT.NX * RT.NY
|
||
for l in RT.LAY:
|
||
field = bytearray([HUG_PEN]) * n
|
||
for (x0, y0, x1, y1) in band.get(l, []):
|
||
i0, i1 = max(0, int(x0 / RT.G)), min(RT.NX - 1, int(math.ceil(x1 / RT.G)))
|
||
j0, j1 = max(0, int(y0 / RT.G)), min(RT.NY - 1, int(math.ceil(y1 / RT.G)))
|
||
z = bytes(i1 - i0 + 1)
|
||
for j in range(j0, j1 + 1):
|
||
field[j * RT.NX + i0: j * RT.NX + i1 + 1] = z
|
||
g.pen[l] = bytearray(map(max, g.pen[l], field))
|
||
|
||
|
||
def _seg_box(s, m):
|
||
return (min(s[1], s[3]) - m, min(s[2], s[4]) - m, max(s[1], s[3]) + m, max(s[2], s[4]) + m)
|
||
|
||
|
||
# ── 各阶段 ───────────────────────────────────────────────────────────────
|
||
def kelvin(pads, segs, vias, board_vias, logs):
|
||
padmap = {(q[0], str(q[1])): q for q in pads}
|
||
out_s, out_v = [], []
|
||
for aa, bb, w in KELVIN:
|
||
pa, pb = padmap.get(aa), padmap.get(bb)
|
||
if not pa or not pb:
|
||
logs.append(u'Kelvin: 找不到 %s.%s / %s.%s' % (aa + bb))
|
||
continue
|
||
halfk = w / 2.0 + RT.CLR
|
||
g, gt, others = grid_now(pads, halfk, segs + out_s, vias + out_v, board_vias)
|
||
na = RT.pad_nodes(g, pa, halfk, others.get(pa[6], []), w / 2.0, gt)
|
||
nb = RT.pad_nodes(g, pb, halfk, others.get(pb[6], []), w / 2.0, gt)
|
||
path = _astar_l4(g, na[:16], nb[:16], pa[7], halfk) # Kelvin 只走 L4（第 4 阶段规则）
|
||
if not path:
|
||
logs.append(u'Kelvin: %s.%s → %s.%s 没布通' % (aa + bb))
|
||
continue
|
||
sg, vv = RT.to_segments(path)
|
||
out_s += [(l, x0, y0, x1, y1, w, pa[7]) for (l, x0, y0, x1, y1) in sg]
|
||
out_v += [(x, y, pa[7]) for (x, y) in vv]
|
||
out_s += RT.stub_emit(pa, RT.wx(path[0][1]), RT.wy(path[0][2]), others.get(pa[6], []),
|
||
w / 2.0, w, pa[7], gt)
|
||
out_s += RT.stub_emit(pb, RT.wx(path[-1][1]), RT.wy(path[-1][2]), others.get(pb[6], []),
|
||
w / 2.0, w, pb[7], gt)
|
||
return out_s, out_v
|
||
|
||
|
||
def v12_handoff(pads):
|
||
u"""Rs6.2 西侧 L4 铜块 + 15 个过孔。铜块本身画成若干条同网宽线（铺铜阶段再用正式铜面覆盖）。"""
|
||
bad = []
|
||
x0, y0, x1, y1 = V12_PATCH
|
||
for p in pads:
|
||
if p[6] not in (2, 12) or p[7] == '+12V':
|
||
continue
|
||
r = RT.pad_rect(p)
|
||
d = max(r[0] - x1, x0 - r[2], r[1] - y1, y0 - r[3])
|
||
if d < RB.MIN_CLEARANCE + 0.05:
|
||
bad.append(u'%s.%s(%s) 离 V12_PATCH 只有 %.2f' % (p[0], p[1], p[7], d))
|
||
if bad:
|
||
raise RuntimeError(u'V12_PATCH 与异网焊盘冲突（摆位改过？）：' + u'；'.join(bad))
|
||
segs = []
|
||
h = y1 - y0
|
||
segs.append((2, x0 + h / 2.0, (y0 + y1) / 2.0, x1 - h / 2.0, (y0 + y1) / 2.0, h, '+12V'))
|
||
vias = [(x, y, '+12V') for (x, y) in v12_vias()]
|
||
return segs, vias
|
||
|
||
|
||
# ── J23（Type-C）同名 D± 脚的桥 ─────────────────────────────────────────────
|
||
# 一排里是 B6(DP) A7(DM) A6(DP) B7(DM) 交错，0.5 mm 间距。先布的那根把自己两只脚一桥，
|
||
# 正好横在另一根内侧那只脚的出口上（首轮：UP_DM「A7 出不来」）。
|
||
# ⇒ 两座桥按构造画：DP 从焊盘**南侧**（连接器本体一侧）绕、DM 从**北侧**绕，互不交叉；
|
||
# 之后 A* 只接外侧的 B6（DP，西北方向是空的）和 B7（DM，东北方向是空的）。
|
||
J23_BRIDGE_W = 0.15
|
||
J23_BRIDGE_OUT = 0.6 # 桥的横段离焊盘端多远
|
||
|
||
|
||
def j23_bridges(pads):
|
||
pm = {(q[0], str(q[1])): q for q in pads if q[0] == 'J23'}
|
||
need = [('B6', 'UP_DP'), ('A6', 'UP_DP'), ('A7', 'UP_DM'), ('B7', 'UP_DM')]
|
||
for pin, net in need:
|
||
if ('J23', pin) not in pm or pm[('J23', pin)][7] != net:
|
||
raise RuntimeError(u'J23.%s 不是 %s（封装 / 朝向改过？）' % (pin, net))
|
||
b6, a6, a7, b7 = (pm[('J23', k)] for k in ('B6', 'A6', 'A7', 'B7'))
|
||
if not (b6[2] < a7[2] < a6[2] < b7[2]):
|
||
raise RuntimeError(u'J23 的 D± 脚顺序不是 B6 A7 A6 B7（西 → 东）')
|
||
ys = b6[3] - b6[5] / 2.0 - J23_BRIDGE_OUT # 南
|
||
yn = a7[3] + a7[5] / 2.0 + J23_BRIDGE_OUT # 北
|
||
w = J23_BRIDGE_W
|
||
segs = [(2, b6[2], b6[3], b6[2], ys, w, 'UP_DP'), (2, b6[2], ys, a6[2], ys, w, 'UP_DP'),
|
||
(2, a6[2], ys, a6[2], a6[3], w, 'UP_DP'),
|
||
(2, a7[2], a7[3], a7[2], yn, w, 'UP_DM'), (2, a7[2], yn, b7[2], yn, w, 'UP_DM'),
|
||
(2, b7[2], yn, b7[2], b7[3], w, 'UP_DM')]
|
||
bad = []
|
||
for s in segs:
|
||
for q in pads:
|
||
if q[6] != 2 or q[7] == s[6]:
|
||
continue
|
||
d = _seg_rect_gap(s, RT.pad_rect(q)) - w / 2.0
|
||
if d < RB.MIN_CLEARANCE - 1e-6:
|
||
bad.append(u'%s 桥离 %s.%s(%s) 只有 %.3f' % (s[6], q[0], q[1], q[7] or 'NC', d))
|
||
if bad:
|
||
raise RuntimeError(u'J23 桥净距不够：' + u'；'.join(sorted(set(bad))))
|
||
return segs, {('J23', 'A6'), ('J23', 'A7')}
|
||
|
||
|
||
# （USB3 的 U 形掉头 `usb3_uturn` 2026-09-11 删除：strap 使能后口 1~3 片内对调，北去三对与槽上同序，不再掉头。）
|
||
|
||
|
||
def geom_check(tag, segs, vias, pads, prior_s=(), prior_v=()):
|
||
u"""按构造画的铜没有 A* 占用图兜底，净距必须自己查：焊盘（同层 / 通孔）、此前构造的铜、彼此之间。"""
|
||
c = RB.MIN_CLEARANCE
|
||
bad = []
|
||
r = RT.VIA_D / 2.0
|
||
for s in segs:
|
||
for q in pads:
|
||
if q[6] not in (s[0], 12) or q[7] == s[6]:
|
||
continue
|
||
d = _seg_rect_gap(s, RT.pad_rect(q)) - s[5] / 2.0
|
||
if d < c - 1e-6:
|
||
bad.append(u'%s 线离 %s.%s(%s) %.3f' % (s[6], q[0], q[1], q[7] or 'NC', d))
|
||
for (vx, vy, net) in vias:
|
||
for q in pads:
|
||
if q[7] == net:
|
||
continue
|
||
d = _seg_rect_gap((0, vx, vy, vx, vy), RT.pad_rect(q)) - r
|
||
if d < c - 1e-6:
|
||
bad.append(u'%s 孔离 %s.%s(%s) %.3f' % (net, q[0], q[1], q[7] or 'NC', d))
|
||
alls = list(segs) + list(prior_s)
|
||
allv = list(vias) + list(prior_v)
|
||
for s in segs:
|
||
for t in alls:
|
||
if t is s or t[6] == s[6] or t[0] != s[0]:
|
||
continue
|
||
d = _seg_seg(s, t) - s[5] / 2.0 - t[5] / 2.0
|
||
if d < c - 1e-6:
|
||
bad.append(u'%s 线离 %s 线 %.3f' % (s[6], t[6], d))
|
||
for (vx, vy, net) in allv:
|
||
if net == s[6]:
|
||
continue
|
||
d = _seg_seg(s, (0, vx, vy, vx, vy)) - s[5] / 2.0 - r
|
||
if d < c - 1e-6:
|
||
bad.append(u'%s 线离 %s 孔 %.3f' % (s[6], net, d))
|
||
for (vx, vy, net) in vias:
|
||
for (wx_, wy_, n2) in allv:
|
||
if n2 != net and (wx_, wy_) != (vx, vy) and math.hypot(vx - wx_, vy - wy_) - 2 * r < c - 1e-6:
|
||
bad.append(u'%s 孔离 %s 孔 %.3f' % (net, n2, math.hypot(vx - wx_, vy - wy_) - 2 * r))
|
||
for t in prior_s:
|
||
if t[6] != net and _seg_seg(t, (0, vx, vy, vx, vy)) - t[5] / 2.0 - r < c - 1e-6:
|
||
bad.append(u'%s 孔离 %s 线' % (net, t[6]))
|
||
bad += _npth_bad(segs, vias)
|
||
if bad:
|
||
raise RuntimeError(u'%s 几何不过：%s' % (tag, u'；'.join(sorted(set(bad)))))
|
||
|
||
|
||
def _npth_bad(segs, vias):
|
||
u"""构造铜 vs 封装自带的 NPTH（按反焊盘半径，所有层 —— 孔是穿透的）。"""
|
||
bad = []
|
||
for (hx, hy, _hr, ar) in NPTH:
|
||
pt = (0, hx, hy, hx, hy)
|
||
for s in segs:
|
||
d = _seg_seg(s, pt) - s[5] / 2.0 - ar
|
||
if d < 0:
|
||
bad.append(u'%s 线压 NPTH(%.2f, %.2f) %.3f' % (s[6], hx, hy, d))
|
||
for (vx, vy, net) in vias:
|
||
d = math.hypot(vx - hx, vy - hy) - RT.VIA_D / 2.0 - ar
|
||
if d < 0:
|
||
bad.append(u'%s 孔压 NPTH(%.2f, %.2f) %.3f' % (net, hx, hy, d))
|
||
return bad
|
||
|
||
|
||
# ── U32 北沿 5 / 10 脚（VDDA33）+ 13 / 19 脚（GND）：按构造画（2026-09-11 第 4 阶段重画）──────────
|
||
# strap 使能后北沿西 → 东：DP1 DM1 DP2 DM2 **3V3(5)** DP3 DM3 DM4 DP4 **3V3(10)** DM5 DP5 **GND(13)** NC NC NC。
|
||
# 5 / 10 脚夹在 D± 中间，既要去耦也要供电：
|
||
# 脚 → L4 竖线一路北上 → 半路横接一小段到电容 C750 / C747 的 +3V3_HUB 脚（电容在正北窄带、偏在线的一侧，
|
||
# place_base.HUB_SAT）→ 到 J36 两排之间打孔上 L1（窄带正上方是 J36 南排焊盘，孔只能落在两排之间）
|
||
# → L1 沿两排之间东去 → 东头打孔回 L4（虚拟落点 fan:e3v3，交给 A* 接回 +3V3_HUB 那一路）。
|
||
# 电容地脚朝北，地孔同样落在两排之间（离 J36 南排焊盘内端 0.55，比供电孔低 0.15 让开 USB4 的横段）。
|
||
# 13 / 19 脚改成 GND 之后，从焊盘内端直接接散热盘（EP）—— 散热盘自己有孔阵下平面。
|
||
U32N_W = 0.2
|
||
# 供电孔（相对脚 x，相对 J36 南排焊盘内端 y）：5 脚东边 0.5 是 USB3_DP 竖线，10 脚西边 0.5 是 USB4_DP。
|
||
# 5 脚的孔抬到 1.05：C750 的地孔要落在 USB3_DM 的 L1 竖线（x 48.5）以东 ≥ 0.59，只剩 49.1 这一格，
|
||
# 孔距 ≥ 0.75 ⇒ 供电孔往北让。
|
||
U32N_V = {'5': (-0.11, 1.05), '10': (0.20, 0.70)}
|
||
# 电容地孔（相对电容 x，相对 J36 南排焊盘内端 y）
|
||
U32N_G = {'C750': (-0.10, 0.50), 'C747': (0.35, 0.55)}
|
||
U32N_CAP = {'5': 'C750', '10': 'C747'}
|
||
U32N_EAST = 66.0 # L1 供电线东头落孔 x（USB4 车道 62.0 以东、J36 东定位柱 67.30 以西）
|
||
U32N_L1Y = 1.60 # L1 供电横线离 J36 南排焊盘内端（两颗供电孔、两颗电容地孔都在它南边）
|
||
U32N_EP_W = 0.25
|
||
|
||
|
||
def u32_north(pads, prior_s, prior_v):
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
for k, net in (('5', '+3V3_HUB'), ('10', '+3V3_HUB'), ('13', 'GND'), ('19', 'GND'), ('65', 'GND')):
|
||
if pm[('U32', k)][7] != net:
|
||
raise RuntimeError(u'U32.%s 是 %s 不是 %s（原理图 / 导入改过？）' % (k, pm[('U32', k)][7], net))
|
||
n, w = '+3V3_HUB', U32N_W
|
||
sdp = pm[('J36', '46')]
|
||
y_in = sdp[3] + sdp[5] / 2.0 # J36 南排焊盘内端（北沿）
|
||
segs, vias, done = [], [], set()
|
||
feed = []
|
||
for pk in ('5', '10'):
|
||
p = pm[('U32', pk)]
|
||
cap = U32N_CAP[pk]
|
||
cp = [q for q in pads if q[0] == cap and q[7] == n]
|
||
cg = [q for q in pads if q[0] == cap and q[7] == 'GND']
|
||
if len(cp) != 1 or len(cg) != 1:
|
||
raise RuntimeError(u'%s 的焊盘不是一只 +3V3_HUB + 一只 GND' % cap)
|
||
cp, cg = cp[0], cg[0]
|
||
vx = round(p[2] + U32N_V[pk][0], 3)
|
||
vy = round(y_in + U32N_V[pk][1], 3)
|
||
segs += _poly2(2, [(p[2], p[3]), (p[2], round(vy - abs(vx - p[2]), 3)), (vx, vy)], w, n)
|
||
segs += _poly2(2, [(p[2], cp[3]), (cp[2], cp[3])], w, n)
|
||
gx, gy = round(cg[2] + U32N_G[cap][0], 3), round(y_in + U32N_G[cap][1], 3)
|
||
segs += _poly2(2, [(cg[2], cg[3]), (gx, gy)], 0.3, 'GND')
|
||
vias += [(vx, vy, n), (gx, gy, 'GND')]
|
||
feed.append((vx, vy))
|
||
done |= {('U32', pk), (cap, str(cp[1])), (cap, str(cg[1]))}
|
||
# L1：两颗供电孔各一小段竖线上到横线，横线在两颗电容地孔之北（孔是通孔，L1 的线不能从它上面过）
|
||
yl = round(y_in + U32N_L1Y, 3)
|
||
for vx, vy in feed:
|
||
segs += _poly2(1, [(vx, vy), (vx, yl)], 0.3, n)
|
||
segs += _poly2(1, [(min(f[0] for f in feed), yl), (U32N_EAST, yl)], 0.3, n)
|
||
vias.append((U32N_EAST, yl, n))
|
||
ep = pm[('U32', '65')]
|
||
p13, p19 = pm[('U32', '13')], pm[('U32', '19')]
|
||
segs += [(2, p13[2], p13[3], p13[2], round(ep[3] + ep[5] / 2.0 - 0.3, 3), U32N_EP_W, 'GND'),
|
||
(2, p19[2], p19[3], round(ep[2] + ep[4] / 2.0 - 0.3, 3), p19[3], U32N_EP_W, 'GND')]
|
||
done |= {('U32', '13'), ('U32', '19')}
|
||
geom_check(u'U32 北沿 5/10 供电 + 去耦、13/19 接散热盘', segs, vias, pads, prior_s, prior_v)
|
||
virt = [['U32', 'fan:e3v3', U32N_EAST, yl, 0.3, 0.3, 2, n, 'VIA']] # 落在 (U32N_EAST, yl) 那颗孔上
|
||
return segs, vias, done, virt
|
||
|
||
|
||
# ── U32 西沿 60~63 脚（晶振 / VDD18PLL / RBIAS）：按构造画（2026-09-11）──────────────────────
|
||
# 第 16 轮服务器重布这四个网全没通。根因：上行 D± 的 GND 回流孔（dp_return_vias，信号网之前落孔）挑了
|
||
# 离换层孔最近的空格 (45.12, 40.62)，正好堵死 60/61 脚往西的直出通道（y 40.22~41.02）；XTAL2 只好北绕，
|
||
# 绕出来的线又把 61/62/63 圈在它和芯片之间。先画死，回流孔 / A* 都会让开。全在 L4、不打孔（NOVIA_NETS）。
|
||
# XTAL2：60 脚沿脚心线直西进 Y1.3。
|
||
# XTAL1：61 脚西去，过了 Y1.3 东沿斜上到 Y1 上下两排焊盘正中（盘距 0.5，0.15 线两边各 ~0.175），
|
||
# 西到 Y1.1 那一列再竖直进盘。Y1 是对角焊盘、XTAL1 的盘在远端 —— 另一条路是从 Y1 北边绕到 C740，长近一倍。
|
||
# VDD18PLL / RBIAS：各一条 45° 折线到 C743.1 / R708.1。
|
||
# Y1.1 / Y1.3 留在 A* 名单里：它们还要接各自的负载电容和 R723（A* 只走 L4）。
|
||
U32W_W = {'XTAL1': 0.15, 'XTAL2': 0.15, 'VDD18PLL': 0.2, 'RBIAS': 0.2, '+3V3_HUB': 0.2}
|
||
U32W_XT2_DY = 0.07 # XTAL2 走线比 60 脚脚心线高（让上行 DP 孔）
|
||
U32W_XT1_DX = 0.5 # XTAL1 开始斜上处离 Y1.3 东沿
|
||
U32W_XT1_IN = 0.35 # XTAL1 竖直进 Y1.1 处离盘心（往东，靠两列之间）
|
||
U32W_STUB = {'62': 0.7, '63': 0.6, '57': 0.6, '52': 0.6} # 出脚先平直西去的长度（让开相邻脚）
|
||
U32W_57_DY = 0.55 # 57 脚 45° 下到 NC 55/56 那一段的落差（离上行 DM 孔 ≥ 0.72）
|
||
U32W_57_DX = 0.53 # 57 脚最后 45° 进 C745.1 的斜段水平长度
|
||
U32W_RB_DX = 0.17 # RBIAS 竖段离 R708.1 盘心（往东）
|
||
|
||
|
||
def u32_west(pads, prior_s, prior_v):
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
want = {'60': 'XTAL2', '61': 'XTAL1', '62': 'VDD18PLL', '63': 'RBIAS'}
|
||
for k, net in want.items():
|
||
if pm[('U32', k)][7] != net:
|
||
raise RuntimeError(u'U32.%s 是 %s 不是 %s（原理图 / 导入改过？）' % (k, pm[('U32', k)][7], net))
|
||
|
||
def one(ref, net):
|
||
qs = [q for q in pads if q[0] == ref and q[7] == net]
|
||
if len(qs) != 1:
|
||
raise RuntimeError(u'%s 上 %s 的焊盘不是一只' % (ref, net))
|
||
return qs[0]
|
||
y1, y2, y3 = one('Y1', 'XTAL1'), pm[('Y1', '2')], one('Y1', 'XTAL2')
|
||
c743, r708 = one('C743', 'VDD18PLL'), one('R708', 'RBIAS')
|
||
p60, p61, p62, p63 = (pm[('U32', k)] for k in ('60', '61', '62', '63'))
|
||
segs = []
|
||
# XTAL2：直西，止于 Y1.3 盘心 x。整条比脚心线高 U32W_XT2_DY：脚心线离上行 DP 孔（45.175, 39.83，
|
||
# 外径 0.6）只有 0.125，抬 0.07 后 0.195；起止点仍分别在 60 脚 / Y1.3 焊盘里。
|
||
yx2 = round(p60[3] + U32W_XT2_DY, 3)
|
||
if not (y3[3] - y3[5] / 2.0 < yx2 < y3[3] + y3[5] / 2.0 and yx2 < p60[3] + p60[5] / 2.0):
|
||
raise RuntimeError(u'XTAL2 走线高度出了 60 脚 / Y1.3 焊盘的上下范围（Y1 挪过？）')
|
||
segs += _poly2(2, [(p60[2], yx2), (y3[2], yx2)], U32W_W['XTAL2'], 'XTAL2')
|
||
# XTAL1：两排焊盘正中 y
|
||
gy = round(((y2[3] - y2[5] / 2.0) + (y3[3] + y3[5] / 2.0)) / 2.0, 3)
|
||
xs = round(y3[2] + y3[4] / 2.0 + U32W_XT1_DX, 3)
|
||
xin = round(y1[2] + U32W_XT1_IN, 3)
|
||
segs += _poly2(2, [(p61[2], p61[3]), (xs, p61[3]), (round(xs - (gy - p61[3]), 3), gy),
|
||
(xin, gy), (xin, y1[3])], U32W_W['XTAL1'], 'XTAL1')
|
||
# VDD18PLL：平直西去 → 45° 上到电容那一行 → 进盘
|
||
x62 = round(p62[2] - U32W_STUB['62'], 3)
|
||
segs += _poly2(2, [(p62[2], p62[3]), (x62, p62[3]), (round(x62 - (c743[3] - p62[3]), 3), c743[3]),
|
||
(c743[2], c743[3])], U32W_W['VDD18PLL'], 'VDD18PLL')
|
||
# RBIAS：平直西去 → 45° 斜上到盘心东 0.17 → 竖直上到电阻那一行 → 进盘
|
||
x63 = round(p63[2] - U32W_STUB['63'], 3)
|
||
xr = round(r708[2] + U32W_RB_DX, 3)
|
||
segs += _poly2(2, [(p63[2], p63[3]), (x63, p63[3]), (xr, round(p63[3] + (x63 - xr), 3)),
|
||
(xr, r708[3]), (r708[2], r708[3])], U32W_W['RBIAS'], 'RBIAS')
|
||
# +3V3_HUB 57 / 52 脚（VDDA33）→ 各自的去耦 C745 / C744：57 脚北边是上行 DM 孔、南边是 USB6 DP 线，
|
||
# 52 脚正上方是 USB6 DM 孔 —— 各只有一条缝。第 16 轮两只都没通；上面四条画死之后回流孔改落 (45.25, 38.25)，
|
||
# 又正压 57 脚那条缝。所以一起画死；电容的另一头留给 A* 接回 +3V3_HUB 干线。
|
||
n = '+3V3_HUB'
|
||
c745, c744 = one('C745', n), one('C744', n)
|
||
p57, p52 = pm[('U32', '57')], pm[('U32', '52')]
|
||
if p57[7] != n or p52[7] != n:
|
||
raise RuntimeError(u'U32.57 / U32.52 不是 +3V3_HUB（原理图 / 导入改过？）')
|
||
x57 = round(p57[2] - U32W_STUB['57'], 3)
|
||
y57 = round(p57[3] - U32W_57_DY, 3) # 下到 NC 55/56 脚那一段再西去
|
||
xt = round(c745[2] + U32W_57_DX, 3)
|
||
segs += _poly2(2, [(p57[2], p57[3]), (x57, p57[3]), (round(x57 - U32W_57_DY, 3), y57), (xt, y57),
|
||
(c745[2], round(y57 - U32W_57_DX, 3)), (c745[2], c745[3])], U32W_W[n], n)
|
||
x52 = round(p52[2] - U32W_STUB['52'], 3)
|
||
segs += _poly2(2, [(p52[2], p52[3]), (x52, p52[3]), (round(x52 - (p52[3] - c744[3]), 3), c744[3]),
|
||
(c744[2], c744[3])], U32W_W[n], n)
|
||
geom_check(u'U32 西沿 52/57/60~63 脚（晶振 / VDD18PLL / RBIAS / VDDA33 去耦）', segs, [], pads, prior_s, prior_v)
|
||
done = ({('U32', k) for k in want} | {('U32', '57'), ('U32', '52')} |
|
||
{(c743[0], str(c743[1])), (r708[0], str(r708[1]))})
|
||
return segs, done
|
||
|
||
|
||
# ── U13 东列 3/4 脚（INA_ALERT / SDA）先平直东出一段（2026-09-11，第 22/23 轮）────────────
|
||
# 东列 2/5 脚都是 SCL、3 脚 INA_ALERT、4 脚 SDA，三个网抢同一侧出口：
|
||
# 第 22 轮 SDA 出脚就斜向东北，挡住 INA_ALERT；第 23 轮 INA_ALERT 先布（EARLY_NETS），又把 SDA 挡了。
|
||
# 空间其实够：0.5 间距上 0.15 的平行线净空 0.35。两只中间脚各平直东出 U13F_X，末端给 A* 一个落点；
|
||
# 2/5 两只 SCL 脚照旧（在芯片底下连起来，从两条直出线的南北两侧出）。
|
||
U13F_X = 1.2 # 直出长度（离焊盘东端）
|
||
U13F_W = 0.15
|
||
|
||
|
||
def u13_fan(pads, prior_s, prior_v):
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
segs, done, virt = [], set(), []
|
||
for pk, net in (('3', 'INA_ALERT'), ('4', 'SDA')):
|
||
p = pm[('U13', pk)]
|
||
if p[7] != net:
|
||
raise RuntimeError(u'U13.%s 是 %s 不是 %s（原理图 / 导入改过？）' % (pk, p[7], net))
|
||
x1 = round(p[2] + p[4] / 2.0 + U13F_X, 3)
|
||
segs += _poly2(2, [(p[2], p[3]), (x1, p[3])], U13F_W, net)
|
||
virt.append(['U13', 'fan:%s' % pk, x1, p[3], 0.3, 0.3, 2, net, 'RECT'])
|
||
done.add(('U13', pk))
|
||
geom_check(u'U13 东列 3/4 脚直出', segs, [], pads, prior_s, prior_v)
|
||
return segs, done, virt
|
||
|
||
|
||
# ── U13 东列三个网整体构造出线（2026-09-11，接替 u13_fan）─────────────────────────────
|
||
# u13_fan 只画 1.2 mm 直出，第 24 轮 SDA 从直出末端照样出不去：卡的是出脚之后那一段 ——
|
||
# U13 东边往北只有 R9E（东沿 26.73）与 J36 外壳盘孔阵西列（28.45）之间一条 1.4 mm 的走廊，
|
||
# L1 在 x < 27.8 是 12V 主块、J36 南排 12V 指头压着 y 42.4~46.3。三个网谁先布谁把走廊口封掉。
|
||
# 第 22 轮 SDA / SCL 通、第 23 轮 INA_ALERT 通，两轮各自的出线拼起来并不冲突 ⇒ 按它们画死，各自交给 A*：
|
||
# SCL ：2/5 脚在芯片底下（x 20.5）相连；5 脚东出 → 45° 下到 y 41.9 → 东去 → 孔 (28.3, 41.9) 上 L1
|
||
# （J37 / J36 两个 12V 指头之间那条 L1 横带，第 22 轮 SCL 就是从这里去 U35 的）
|
||
# SDA ：4 脚东出 → 45° 东北 → 在外壳盘孔阵两行（46.95 / 49.0）之间沿 y 48.0 东去 → 孔 (33.0, 48.0) 上 L1
|
||
# （J36 两排之间的 L1）
|
||
# INA_ALERT：3 脚东出 → 45° 东北（与 SDA 平行、中心距 0.354）→ 走廊里 x 27.05 北上到 y 57（R9E.1 以北、C735 以南）
|
||
# 三条都在 L4；+3V3 仍可从 SCL 之南东去再北上（SDA 横线挡了 x 29.5 那条旧路，要在孔 (33.0, 48.0) 以东北上）。
|
||
# 服务器实测（2026-09-11，过孔快照已清掉 131 颗自动布线残孔，离线铜连通口径）：
|
||
# 不构造 31 个网断开（U13 的 SDA 不通）；构造、SDA 孔 31.5 → 33 个（U13 三网全通，多断的在 U35 西头 SCL4 / SDA1）；
|
||
# **SDA 孔 33.0 → 29 个、U13 三网全通**（第 26 轮 v3）。INA 北端 53 / 两处不打孔 与 31.5 版结果完全相同；
|
||
# INA_ALERT 不先布（--no-early）→ 37，INA_ALERT 反而不通。
|
||
U13E_W = 0.15
|
||
U13E_X0 = 22.8 # 3/4/5 脚平直东出到这里再转 45°（离焊盘东端 0.38：让开 2 脚 / 1 脚）
|
||
U13E_LINK_X = 20.5 # SCL 2/5 脚在芯片底下相连的竖线（离 3/4 脚西端 0.3、离 8 脚 +12V 孔 1.45）
|
||
U13E_SCL_Y = 41.9 # SCL 东去 y：孔上 L1 要离 J36 南排 12V 指头（下沿 42.4）≥ 0.15
|
||
U13E_SCL_VX = 28.3 # SCL 孔 x：离 L1 12V 主块东沿 27.8 ≥ 0.15
|
||
U13E_SDA_Y = 48.0 # SDA 东去 y：外壳盘孔阵 (x 28.45/30.55, y 46.95/49.0) 两行正中偏北
|
||
U13E_SDA_VX = 33.0 # SDA 孔 x（外壳盘 L1 东沿 31.0 以东即可；31.5 版多断 4 个网，见上）
|
||
U13E_INA_X = 27.05 # INA_ALERT 竖线 x：离 R9E 东沿 0.245、离孔阵西列 0.325
|
||
U13E_INA_TOP = 57.0 # INA_ALERT 竖线北端（C735.1 下沿 60.39 以南）
|
||
U13E_SCL_VIA = 1 # 0 = 不打孔，L4 末端直接交给 A*（它自己挑层）
|
||
U13E_SDA_VIA = 1
|
||
|
||
|
||
def _u13e_opts():
|
||
u"""`--u13e NAME=VAL`（可多次）：服务器并行试算时改 U13E_* 参数，不用改文件。"""
|
||
g = globals()
|
||
for i, a in enumerate(sys.argv[:-1]):
|
||
if a == '--u13e':
|
||
k, v = sys.argv[i + 1].split('=')
|
||
if 'U13E_' + k not in g:
|
||
raise RuntimeError(u'--u13e 不认识 %s' % k)
|
||
g['U13E_' + k] = float(v)
|
||
|
||
|
||
def u13_esc(pads, prior_s, prior_v):
|
||
_u13e_opts()
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
for pk, net in (('2', 'SCL'), ('3', 'INA_ALERT'), ('4', 'SDA'), ('5', 'SCL')):
|
||
if pm[('U13', pk)][7] != net:
|
||
raise RuntimeError(u'U13.%s 是 %s 不是 %s（原理图 / 导入改过？）' % (pk, pm[('U13', pk)][7], net))
|
||
p2, p3, p4, p5 = (pm[('U13', k)] for k in ('2', '3', '4', '5'))
|
||
w, x0 = U13E_W, U13E_X0
|
||
segs, vias, virt = [], [], []
|
||
# SCL：芯片底下 2 ↔ 5，再从 5 脚东出
|
||
segs += _poly2(2, [(p5[2], p5[3]), (U13E_LINK_X, p5[3]), (U13E_LINK_X, p2[3]), (p2[2], p2[3])], w, 'SCL')
|
||
segs += _poly2(2, [(p5[2], p5[3]), (x0, p5[3]), (round(x0 + (p5[3] - U13E_SCL_Y), 3), U13E_SCL_Y),
|
||
(U13E_SCL_VX, U13E_SCL_Y)], w, 'SCL')
|
||
if U13E_SCL_VIA:
|
||
vias.append((U13E_SCL_VX, U13E_SCL_Y, 'SCL'))
|
||
virt.append(['U13', 'esc:SCL', U13E_SCL_VX, U13E_SCL_Y, 0.3, 0.3, 1 if U13E_SCL_VIA else 2, 'SCL',
|
||
'VIA' if U13E_SCL_VIA else 'RECT'])
|
||
# SDA
|
||
segs += _poly2(2, [(p4[2], p4[3]), (x0, p4[3]), (round(x0 + (U13E_SDA_Y - p4[3]), 3), U13E_SDA_Y),
|
||
(U13E_SDA_VX, U13E_SDA_Y)], w, 'SDA')
|
||
if U13E_SDA_VIA:
|
||
vias.append((U13E_SDA_VX, U13E_SDA_Y, 'SDA'))
|
||
virt.append(['U13', 'esc:SDA', U13E_SDA_VX, U13E_SDA_Y, 0.3, 0.3, 1 if U13E_SDA_VIA else 2, 'SDA',
|
||
'VIA' if U13E_SDA_VIA else 'RECT'])
|
||
# INA_ALERT
|
||
segs += _poly2(2, [(p3[2], p3[3]), (x0, p3[3]), (U13E_INA_X, round(p3[3] + (U13E_INA_X - x0), 3)),
|
||
(U13E_INA_X, U13E_INA_TOP)], w, 'INA_ALERT')
|
||
virt.append(['U13', 'esc:INA', U13E_INA_X, U13E_INA_TOP, 0.3, 0.3, 2, 'INA_ALERT', 'RECT'])
|
||
geom_check(u'U13 东列三个网构造出线', segs, vias, pads, prior_s, prior_v)
|
||
bad = []
|
||
for (vx, vy, _n) in vias: # 孔在 L1 上要让开 12V 大铜（L1 的线要从孔接出去）
|
||
for r in B.l1_12v_rects():
|
||
d = _seg_rect_gap((0, vx, vy, vx, vy), r) - RT.VIA_D / 2.0
|
||
if d < RB.MIN_CLEARANCE - 1e-6:
|
||
bad.append(u'孔 (%.2f,%.2f) 离 12V 大铜 %.3f' % (vx, vy, d))
|
||
if bad:
|
||
raise RuntimeError(u'U13 构造出线的孔压 12V 大铜：' + u'；'.join(bad))
|
||
return segs, vias, {('U13', '2'), ('U13', '3'), ('U13', '4'), ('U13', '5')}, virt
|
||
|
||
|
||
# ── +3V3 定点构造（2026-09-11，用户选「定点改」）─────────────────────────────────────
|
||
# 服务器对照实验（第 18 轮为底）：+3V3 完全不布 ⇒ 信号网 37 → 29；每脚一孔的平面式 ⇒ 33。实测挡路的两段：
|
||
# ① J36 ↔ J35 之间绕 U35 西侧 + J36 过孔带里的 L1 跳线（SDA5；U35 西侧出线的 INT# / SCL4 / SDA1）；
|
||
# ② 电源经 x≈29 从东北斜下去喂 U13 / C11 —— 横在 U13 自己的 SDA / INA_ALERT 往东的出线上。
|
||
# 两段画死，其余 +3V3 脚交给 A*（这两段上标 WALL 落点 = 多源种子，就近接）。
|
||
# A. U35 东侧旁路：J36 北排 9/10 在 L1 并起来 → 槽内孔 J → L4 东到键位缺口列（x 44.0，五个槽这一列两排都没针）
|
||
# → 北上穿 A4M 走廊（U35 东头 x 42.77 以外是空的）→ 西到槽内孔 K → L1 接 J35 南排 40 与北排 9/10。
|
||
# ⚠ 定位柱（NPTH Ø1.21）也在 x 44.15、槽心线上 ⇒ 竖段只在 J36 北排内侧 ~ J35 南排内侧之间，离柱 ≥ 0.56。
|
||
# B. U13 从东南进：U13 的 +3V3（6 脚）在西列最下，西边是 Kelvin、北边是 12V / VIN_SW 脚、东列是信号，南边是 VIN_SW 铜。
|
||
# C11.1 ↔ U13.6 短接，沿 C11 与 U13 之间 y 41.9 东去（在东列信号脚之南，不挡它们往东 / 往北）
|
||
# → x 28.5 孔上 L1（J37 / J36 两个 12V 指头之间 y 35.3~42.4 的 L1 是空的）→ L1 y 39.5 东去横穿 I²C 竖向车道（它们在 L4）
|
||
# → x 39.3 孔回 L4 北上（XTAL1 绕 Y1 西侧的通道在 x ≥ 39.73）→ 槽外孔上 L1 接 J36 南排 40 脚。
|
||
V3T_W = 0.4 # 干线线宽（+3V3 规则宽度）
|
||
V3T_LINK_W = 0.3 # C11.1 ↔ U13.6 短接
|
||
V3T_JOIN = 0.25 # 槽脚 L1 并线离焊盘内端（伸进焊盘）
|
||
V3T_VJ = 0.6 # 孔 J 离 J36 北排内端
|
||
V3T_KY = 0.88 # J35 那头 L4 横段 / 孔 K 离 J35 南排内端
|
||
V3T_KX = 0.5 # 孔 K 在 J35.40 以东
|
||
V3T_BY = 40.45 # B 段 L4 东去的 y：Kelvin IN− 在 y 41.25（线宽 0.3）之下 0.45、C11.2 底 40.98 之下 0.33
|
||
V3T_BX = 28.5 # B 段上 L1 的孔 x（L1 12V 主块东沿 27.8）
|
||
V3T_BL1Y = 39.5 # B 段 L1 东去的 y
|
||
V3T_BX2 = 38.9 # B 段回 L4 的孔 x（第 19 轮 39.3：孔在走线图上保守封到 x 40.0，XTAL1 绕 Y1 西侧那 2 格通道被堵死）
|
||
V3T_BTOP = 0.6 # B 段北端孔离 J36 南排外端（槽外）
|
||
|
||
|
||
def v3_trunk(pads, prior_s, prior_v):
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
n = '+3V3'
|
||
need = [('J36', '9'), ('J36', '10'), ('J36', '40'), ('J35', '9'), ('J35', '10'), ('J35', '40'),
|
||
('J36', '43'), ('J36', '44'), ('U13', '6'), ('C11', '1')]
|
||
for k in need[:6] + need[8:]:
|
||
if pm[k][7] != n:
|
||
raise RuntimeError(u'%s.%s 是 %s 不是 +3V3（原理图 / 导入改过？）' % (k[0], k[1], pm[k][7]))
|
||
segs, vias, virt = [], [], []
|
||
w = V3T_W
|
||
# ── A. U35 东侧旁路 ──
|
||
a9, a10, a40 = pm[('J36', '9')], pm[('J36', '10')], pm[('J36', '40')]
|
||
b9, b10, b40 = pm[('J35', '9')], pm[('J35', '10')], pm[('J35', '40')]
|
||
xk = round((pm[('J36', '43')][2] + pm[('J36', '44')][2]) / 2.0, 3) # 键位缺口列
|
||
a_in = a9[3] - a9[5] / 2.0 # J36 北排内端（南沿）
|
||
b_in = b40[3] + b40[5] / 2.0 # J35 南排内端（北沿）
|
||
b_nin = b9[3] - b9[5] / 2.0 # J35 北排内端
|
||
yj = round(a_in + V3T_JOIN, 3)
|
||
jx, jy = round((a9[2] + a10[2]) / 2.0, 3), round(a_in - V3T_VJ, 3)
|
||
segs += _poly2(1, [(a9[2], yj), (a10[2], yj)], w, n)
|
||
segs += _poly2(1, [(jx, yj), (jx, jy)], w, n)
|
||
ky = round(b_in + V3T_KY, 3)
|
||
kx = round(b40[2] + V3T_KX, 3)
|
||
segs += _poly2(2, [(jx, jy), (xk, jy), (xk, ky), (kx, ky)], w, n)
|
||
segs += _poly2(1, [(kx, ky), (b40[2], round(ky - V3T_KX, 3)), (b40[2], round(b_in - V3T_JOIN, 3))], w, n)
|
||
yb = round(b_nin + V3T_JOIN, 3)
|
||
segs += _poly2(1, [(kx, ky), (b9[2], round(ky + (b9[2] - kx), 3)), (b9[2], yb), (b10[2], yb)], w, n)
|
||
vias += [(jx, jy, n), (kx, ky, n)]
|
||
for ym in (0.35, 0.65): # 旁路竖段在 A4M 走廊里的两处落点（出口多）
|
||
virt.append(['WALL', 'wall', xk, round(jy + (ky - jy) * ym, 3), 0.6, 0.6, 2, n, 'RECT'])
|
||
# ── B. U13 从东南进 ──
|
||
u6, c1 = pm[('U13', '6')], pm[('C11', '1')]
|
||
# ⚠ Kelvin IN−（+12V，只走 L4，最先布）从 U13.9 往东、从芯片底下穿到南边沿 y 41.25 东去再绕上来 ——
|
||
# U13.6 / C11 在它外面（西南角），馈线只能从它下面走：C11.1 往下到 V3T_BY 再东去（离那段 0.45）。
|
||
# 代价：C11 本来就坐在 VIN_SW 铜的东北角里，这条线在 VIN_SW-2 顶端（x 17.1~19.75）划一道 ~0.7 的缝。
|
||
# 在 C11.1 盘心断一下：布线器的连通自检只认「端点落在焊盘里」，穿盘而过会报「C11.1 一根铜都没有」（第 19 轮）
|
||
segs += _poly2(2, [(c1[2], u6[3]), (c1[2], c1[3]), (c1[2], V3T_BY)], V3T_LINK_W, n)
|
||
x1 = round(V3T_BX - (V3T_BY - V3T_BL1Y), 3) # 45° 下到孔
|
||
segs += _poly2(2, [(c1[2], V3T_BY), (x1, V3T_BY), (V3T_BX, V3T_BL1Y)], w, n)
|
||
segs += _poly2(1, [(V3T_BX, V3T_BL1Y), (V3T_BX2, V3T_BL1Y)], w, n)
|
||
a_out = a40[3] - a40[5] / 2.0 # J36 南排外端（南沿）
|
||
ytop = round(a_out - V3T_BTOP, 3)
|
||
# L4 竖线不在槽外停：继续北上穿 J36 槽内到孔 J 那一行，东接孔 J —— A、B 两段必须是**一整块铜**。
|
||
# 第 19 轮两段各自为政（A 接 J36 北排 9/10、B 接南排 40，同槽两排在板上不相通），两组 WALL 落点坐在两块不相连的铜上，
|
||
# +3V3 断成 6 块（离线铜连通检查查出来的，布线器自检没报）。
|
||
# 在槽外孔 (V3T_BX2, ytop) 处断一下：孔要落在线段端点上（连通自检只认端点）
|
||
segs += _poly2(2, [(V3T_BX2, V3T_BL1Y), (V3T_BX2, ytop), (V3T_BX2, jy), (jx, jy)], w, n)
|
||
segs += _poly2(1, [(V3T_BX2, ytop), (a40[2], round(ytop + (a40[2] - V3T_BX2), 3)),
|
||
(a40[2], round(a_out + V3T_JOIN, 3))], w, n)
|
||
vias += [(V3T_BX, V3T_BL1Y, n), (V3T_BX2, V3T_BL1Y, n), (V3T_BX2, ytop, n)]
|
||
virt.append(['WALL', 'wall', round((V3T_BX + V3T_BX2) / 2.0, 3), V3T_BL1Y, 0.6, 0.6, 1, n, 'RECT'])
|
||
# 焊盘 / 已有构造铜的净距；L1 另查 12V 大铜（铺铜矩形不在焊盘表里）
|
||
geom_check(u'+3V3 定点构造（U35 东侧旁路 + U13 东南进）', segs, vias, pads, prior_s, prior_v)
|
||
bad = []
|
||
rects12 = B.l1_12v_rects() # 主块 + 各槽 12V 指头（[0] 只是主块）
|
||
for s in segs:
|
||
if s[0] != 1:
|
||
continue
|
||
for r in rects12:
|
||
d = _seg_rect_gap(s, r) - s[5] / 2.0
|
||
if d < RB.MIN_CLEARANCE - 1e-6:
|
||
bad.append(u'L1 线 (%.2f,%.2f)-(%.2f,%.2f) 离 12V 大铜 %.3f' % (s[1], s[2], s[3], s[4], d))
|
||
for (vx, vy, _n) in vias:
|
||
for r in rects12:
|
||
d = _seg_rect_gap((0, vx, vy, vx, vy), r) - RT.VIA_D / 2.0
|
||
if d < RB.MIN_CLEARANCE - 1e-6:
|
||
bad.append(u'孔 (%.2f,%.2f) 离 12V 大铜 %.3f' % (vx, vy, d))
|
||
if bad:
|
||
raise RuntimeError(u'+3V3 定点构造压 12V 大铜：' + u'；'.join(bad))
|
||
done = {('J36', '9'), ('J36', '10'), ('J35', '9'), ('J35', '10'), ('J35', '40'),
|
||
('J36', '40'), ('U13', '6'), ('C11', '1')}
|
||
return segs, vias, done, virt
|
||
|
||
|
||
# ── 其余 D± 按构造画（2026-09-10 用户选定：构造 D± + 划横穿车道）────────────────────
|
||
# A* 逐网布 D± 不认拓扑：DP 抄最短路把自家 DM 的出口封死（第四轮 USB2/4/5/6 的 DM 全「出不来」）。
|
||
# 规则只有一条：**槽上 D+ 在西、D− 在东 ⇒ 这一对必须「向南」进焊盘**（掉头 / 绕行都保持 DM 在行进方向左侧）。
|
||
# 北去（USB1 → J34、USB2 → J35）：出脚 45° 往西让开 USB3 的 U 形，北上到目标槽，在两排之间**向东掉头**，
|
||
# 打孔上 L1、从北边进焊盘内端。
|
||
# 南去（USB4 → J37、USB5 → J38）：出脚向东（USB5 在 13 脚那条线上面、USB4 在 10 脚过孔上面），
|
||
# 到 DP_H 车道南下。USB4 在内圈外侧 ⇒ 转回西时必然横过 USB5 —— 用它本来就要的 L4→L1 那一跳：
|
||
# 在 J37 两排之间打孔上 L1、在 L1 上向西进焊盘；USB5 在 L4 从它底下继续南下到 J38 再向西打孔。
|
||
# 上行 / USB6：在 U32 西侧过孔带（place_base.LANES['U32_WVIA']）各打两颗交错孔上 L1，之后交给 A*（从 L1 起步）。
|
||
DPC_JOG_W = 0.25 # 北去四根出脚后的转弯高度步进（45° 斜段互相平行、中心距 ≥ 0.5）
|
||
# 北上竖线 x = 出脚 x − SHIFT。2026-09-10 由 3.5 / 2.5 改：原来 USB1 竖线在 x 44.25 / 44.75，
|
||
# 正压在 J36/J35/J34 的西定位柱（x 44.15，反焊盘半径 0.958）上。现在四根 45.28 / 45.78 / 46.40 / 46.90：
|
||
# 西界 = 44.15 + 0.958 + 线半宽；东界 = USB3 掉头在 J36 的过孔（x 47.5）− 孔半径 − 0.15 − 线半宽 = 46.91。
|
||
DPC_SHIFT = {'USB1': 2.47, 'USB2': 2.35}
|
||
DPC_VIA = 1.0 # 南去（USB4/5）：过孔离目标焊盘内端
|
||
DPC_VIA_S = 0.45 # 北去（USB1/2）：过孔离目标焊盘南端（从南边进）
|
||
DPC_UT = 0.5 # 北去：DP 横段在孔南 0.5、DM 横段在孔南 1.0
|
||
DPC_U3 = (1.8, 2.5) # USB3 DP / DM 西拐横段离 J36 南排焊盘内端（在 5 脚供电孔 47.45 / C750 地孔之北）
|
||
# 离 DP_H 车道西沿（DP, DM）。USB4 两根拉开到 0.7：DM 的 L4 竖线要一直下到自己的孔（在 DP 孔南边），
|
||
# 0.5 的话它擦过 DP 的孔只剩 0.06（静态校验实测）。
|
||
DPC_LANE = {'USB5': (0.0, 0.5), 'USB4': (1.8, 2.5)}
|
||
DPC_Y5 = (0.3, 0.8) # USB5 DP / DM 东拐横段离北排焊盘外端（C747 下沿 44.58 在 DM 之上）
|
||
DPC_Y4 = (1.35, 1.85) # USB4 DP / DM 东拐横段离 J36 南排焊盘内端（10 脚供电孔之北 0.21）
|
||
WVIA_DX = (0.85, 1.45) # USB6/UP 两颗孔离西排焊盘外沿（DM, DP）
|
||
|
||
|
||
def _poly2(layer, pts, w, net):
|
||
return [(layer, a[0], a[1], b[0], b[1], w, net) for a, b in zip(pts, pts[1:])
|
||
if abs(a[0] - b[0]) + abs(a[1] - b[1]) > 1e-9]
|
||
|
||
|
||
def dp_construct(pads, prior_s, prior_v):
|
||
import place_base as PL
|
||
pm = {(q[0], str(q[1])): q for q in pads}
|
||
u = lambda k: pm[('U32', k)] # noqa: E731
|
||
w = DIFF_W
|
||
segs, vias, done, virt = [], [], set(), []
|
||
top = u('1')[3] + u('1')[5] / 2.0
|
||
|
||
def slot(i):
|
||
ref = B.USB_SLOT_REF[i]
|
||
sp, sm = pm[(ref, '46')], pm[(ref, '47')]
|
||
done.update({(ref, '46'), (ref, '47')})
|
||
return sp, sm
|
||
|
||
def chk(pk, net):
|
||
if u(pk)[7] != net:
|
||
raise RuntimeError(u'U32.%s 是 %s 不是 %s（口 1~3 片内对调的端口名换过？）' % (pk, u(pk)[7], net))
|
||
|
||
# 北去 USB1 / USB2：出脚按脚序阶梯 45° 西去、上车道北上；到目标槽南排外侧东拐到焊盘 x，
|
||
# 在焊盘南端外打孔上 L1 从南边进（口 1~3 已片内对调，DP 在西 = 槽上 D+ 在西，不用掉头）。
|
||
# DP 横段在北（离孔 DPC_UT）、DM 横段在南（2×）—— DM 去的焊盘在东，横段必须在 DP 竖线之下。
|
||
k = 0
|
||
for name, pdp, pdm in (('USB1', '1', '2'), ('USB2', '3', '4')):
|
||
dp_net, dm_net = PAIRS[name]
|
||
chk(pdp, dp_net)
|
||
chk(pdm, dm_net)
|
||
sp, sm = slot(int(name[3]))
|
||
s = DPC_SHIFT[name]
|
||
yv = round(sp[3] - sp[5] / 2.0 - DPC_VIA_S, 3)
|
||
for net, pk, t, yt in ((dp_net, pdp, sp, yv - DPC_UT), (dm_net, pdm, sm, yv - 2 * DPC_UT)):
|
||
q = u(pk)
|
||
ya = round(top + 0.3 + k * DPC_JOG_W, 3)
|
||
k += 1
|
||
x1 = round(q[2] - s, 3)
|
||
pts = [(q[2], q[3]), (q[2], ya), (x1, round(ya + s, 3)), (x1, round(yt, 3)), (t[2], round(yt, 3)),
|
||
(t[2], yv)]
|
||
segs += _poly2(2, pts, w, net)
|
||
segs += _poly2(1, [(t[2], yv), (t[2], t[3])], w, net)
|
||
vias.append((t[2], yv, net))
|
||
done.add(('U32', pk))
|
||
|
||
# USB3：两根贴着 C750 东侧直直北上（L4 从 J36 南排底下过），到两排之间西拐到焊盘 x，
|
||
# 打孔上 L1 从北边进焊盘内端。DP 先拐（低）、DM 后拐（高）：DM 的孔在东，横段在 DP 之上。
|
||
sp3, sm3 = slot(3)
|
||
y_in3 = sp3[3] + sp3[5] / 2.0
|
||
for net, pk, t, dy in ((PAIRS['USB3'][0], '6', sp3, DPC_U3[0]), (PAIRS['USB3'][1], '7', sm3, DPC_U3[1])):
|
||
chk(pk, net)
|
||
q = u(pk)
|
||
yh = round(y_in3 + dy, 3)
|
||
segs += _poly2(2, [(q[2], q[3]), (q[2], yh), (t[2], yh)], w, net)
|
||
segs += _poly2(1, [(t[2], yh), (t[2], t[3])], w, net)
|
||
vias.append((t[2], yh, net))
|
||
done.add(('U32', pk))
|
||
|
||
# 南去：USB5（内圈，出脚就东拐，C747 压在它上面）/ USB4（外圈，北上越过 5/10 脚的供电孔与电容地孔再东去）
|
||
lane_x = PL.LANES['DP_H'][0]
|
||
sp5, sm5 = slot(5)
|
||
y_in5 = sp5[3] + sp5[5] / 2.0
|
||
yv5 = round(y_in5 + DPC_VIA, 3)
|
||
xdp5, xdm5 = round(lane_x + DPC_LANE['USB5'][0], 3), round(lane_x + DPC_LANE['USB5'][1], 3)
|
||
wdm5, wdp5 = round(yv5 + 0.64, 3), round(yv5 + 1.14, 3)
|
||
for net, pk, yh, xl, yw, xt in ((PAIRS['USB5'][0], '12', top + DPC_Y5[0], xdp5, wdp5, sp5[2]),
|
||
(PAIRS['USB5'][1], '11', top + DPC_Y5[1], xdm5, wdm5, sm5[2])):
|
||
chk(pk, net)
|
||
q = u(pk)
|
||
yh = round(yh, 3)
|
||
pts = [(q[2], q[3]), (q[2], yh), (xl, yh), (xl, yw), (xt, yw), (xt, yv5)]
|
||
segs += _poly2(2, pts, w, net)
|
||
segs += _poly2(1, [(xt, yv5), (xt, sp5[3])], w, net)
|
||
vias.append((xt, yv5, net))
|
||
done.add(('U32', pk))
|
||
sp4, sm4 = slot(4)
|
||
y_in4 = sp4[3] + sp4[5] / 2.0
|
||
xdp4, xdm4 = round(lane_x + DPC_LANE['USB4'][0], 3), round(lane_x + DPC_LANE['USB4'][1], 3)
|
||
vdp4, vdm4 = round(y_in4 + 4.32, 3), round(y_in4 + 3.52, 3) # 交错两颗孔（J37 两排之间）
|
||
for net, pk, yh, xl, yvv, xt in ((PAIRS['USB4'][0], '9', y_in3 + DPC_Y4[0], xdp4, vdp4, sp4[2]),
|
||
(PAIRS['USB4'][1], '8', y_in3 + DPC_Y4[1], xdm4, vdm4, sm4[2])):
|
||
chk(pk, net)
|
||
q = u(pk)
|
||
yh = round(yh, 3)
|
||
segs += _poly2(2, [(q[2], q[3]), (q[2], yh), (xl, yh), (xl, yvv)], w, net)
|
||
segs += _poly2(1, [(xl, yvv), (xt, yvv), (xt, sp4[3])], w, net)
|
||
vias.append((xl, yvv, net))
|
||
done.add(('U32', pk))
|
||
|
||
# 上行 / USB6：西侧过孔带里各两颗交错孔，之后从 L1 起步
|
||
west = [q for q in pads if q[0] == 'U32' and not is_ep(q) and q[4] > q[5]]
|
||
x_left = min(q[2] - q[4] / 2.0 for q in west)
|
||
for name, pdm, pdp in (('USB6', '53', '54'), ('USBUP', '58', '59')):
|
||
dp_net, dm_net = PAIRS[name]
|
||
for net, pk, dx, dy in ((dm_net, pdm, WVIA_DX[0], -0.25), (dp_net, pdp, WVIA_DX[1], 0.0)):
|
||
q = u(pk)
|
||
vx, vy = round(x_left - dx, 3), round(q[3] + dy, 3)
|
||
pts = [(q[2], q[3]), (round(x_left - 0.35, 3), q[3]), (vx, vy)]
|
||
segs += _poly2(2, pts, 0.2, net)
|
||
vias.append((vx, vy, net))
|
||
virt.append(['U32', 'fan:%s' % pk, vx, vy, 0.3, 0.3, 1, net, 'RECT'])
|
||
done.add(('U32', pk))
|
||
geom_check(u'D± 构造（USB1/2/4/5 + 上行/USB6 西侧孔）', segs, vias, pads, prior_s, prior_v)
|
||
return segs, vias, done, virt
|
||
|
||
|
||
# ── 通用扇出：这几颗芯片的每只非地、非 D± 脚先打一个孔上 L1，布线从 L1 的落点起步 ─────────
|
||
FANOUT_REFS = ('U35', 'U6', 'U7', 'U20')
|
||
FAN_W = 0.15
|
||
# 这几个分区里**所有件**的非地信号脚也扇出（第五轮：D± 全通之后剩 37 个网，21 条在 U20 北沿那排上拉 /
|
||
# NTC 阻容上 —— 0402 一字排开、两头都在 L4，头顶的 L1 是空的却上不去）。
|
||
# ⚠ A4H（U32 那条走廊）**不扇**：那里的晶振 / RBIAS / strap 要和 U32 的脚在 L4 就近连，打孔反而绕远。
|
||
# ⚠ U31（LDO，宽电源脚）与 J23（Type-C，0.5 间距，出口带另有安排）不扇。
|
||
# ⛔ 第七轮实测**反效果**（信号网 37 → 43、GND 打孔失败 97 → 106）：小件挨着排（0.6 mm 装配间距），
|
||
# 每只焊盘就近打孔 = 把 L4 上的一簇件变成两层都占的一簇孔，A3 里两头都已在 L1 的脚照样「没布通」。
|
||
# 根子在摆位间距，不在扇出。先关掉，留着代码。
|
||
FAN_ZONES = ()
|
||
FAN_ZONE_SKIP = ('U31', 'J23', 'J33')
|
||
|
||
|
||
def fan_zone_refs():
|
||
import place_base as PL
|
||
pg = PL.page_of()
|
||
return set(r for r in pg if r not in FAN_ZONE_SKIP and PL.zone_of_ref(r, pg) in FAN_ZONES)
|
||
|
||
|
||
# U20 的脚距 1.27：最近的落点排成一列、孔距 1.27 ⇒ 在 L1 上连成一道墙（第四轮 29 条失败在 U20 周围）。
|
||
# ⇒ 奇数脚往外多让 FAN_STAGGER，孔错成两排。
|
||
FAN_STAGGER = {'U20': 1.0}
|
||
|
||
|
||
def fanout(pads, bypad, segs, vias, board_vias, logs):
|
||
u"""原地改 bypad：扇出成功的脚换成 L1 上的虚拟落点 `fan:<脚号>`。返回 (segs, vias, 成功数, 失败数)。"""
|
||
halfv = RT.VIA_D / 2.0 + RT.CLR
|
||
g, gt, others = grid_now(pads, halfv, segs, vias, board_vias)
|
||
sh = FAN_W / 2.0
|
||
todo = []
|
||
zref = fan_zone_refs()
|
||
for net, ps in bypad.items():
|
||
if net in DP_NETS or net in PLANE_NETS:
|
||
continue
|
||
for q in ps:
|
||
if (q[0] in FANOUT_REFS or q[0] in zref) and not RT._is_launch(q) and q[6] in RT.LAY \
|
||
and (q[0], str(q[1])) not in TH_KEYS:
|
||
todo.append(q)
|
||
|
||
def cands(q):
|
||
return [nd for nd in RT.pad_nodes(g, q, halfv, others.get(q[6], []), sh, gt)
|
||
if g.free_via(nd[1], nd[2], q[7])]
|
||
|
||
# 朝目的地落孔（2026-09-11 第 31 轮，`--fan-dir W` 才开）：原来只挑「离焊盘最近」的空格点，不管这个网要去哪 ——
|
||
# U20 重分配的六组试算里 RXD0 全断：它的扇出孔落在北排焊盘南边（模组本体一侧），J33 在北 18 mm。
|
||
# 候选按 距离 + W × 背离程度（0 = 朝目的地 / 侧向，1 = 正背离）排；目的地 = 本网其余脚（含落点）的质心。
|
||
fan_dir_w = float(sys.argv[sys.argv.index('--fan-dir') + 1]) if '--fan-dir' in sys.argv else 0.0
|
||
|
||
def toward(q, cs):
|
||
oth = [o for o in bypad.get(q[7], []) if o is not q]
|
||
if not fan_dir_w or not oth:
|
||
return cs
|
||
ux = sum(o[2] for o in oth) / len(oth) - q[2]
|
||
uy = sum(o[3] for o in oth) / len(oth) - q[3]
|
||
L = math.hypot(ux, uy) or 1.0
|
||
ux, uy = ux / L, uy / L
|
||
|
||
def key(nd):
|
||
x, y = RT.wx(nd[1]) - q[2], RT.wy(nd[2]) - q[3]
|
||
d = math.hypot(x, y) or 1e-9
|
||
return d + fan_dir_w * max(0.0, -(x * ux + y * uy) / d)
|
||
return sorted(cs, key=key)
|
||
|
||
todo.sort(key=lambda q: (len(cands(q)), q[0], str(q[1])))
|
||
out_s, out_v, ok, fail = [], [], 0, 0
|
||
for q in todo:
|
||
cs = toward(q, cands(q))
|
||
if not cs:
|
||
fail += 1
|
||
continue
|
||
nd = cs[0]
|
||
stg = FAN_STAGGER.get(q[0], 0.0)
|
||
if stg and str(q[1]).isdigit() and int(q[1]) % 2:
|
||
d0 = math.hypot(RT.wx(cs[0][1]) - q[2], RT.wy(cs[0][2]) - q[3])
|
||
far = [c2 for c2 in cs if math.hypot(RT.wx(c2[1]) - q[2], RT.wy(c2[2]) - q[3]) >= d0 + stg]
|
||
if far:
|
||
nd = far[0]
|
||
vx, vy = RT.wx(nd[1]), RT.wy(nd[2])
|
||
ss = RT.stub_emit(q, vx, vy, others.get(q[6], []), sh, FAN_W, q[7], gt)
|
||
out_s += ss
|
||
out_v.append((vx, vy, q[7]))
|
||
keep = halfv + FAN_W / 2.0
|
||
for (l, a, b, c, d, ww, nn) in ss:
|
||
RT.block_track(g, l, a, b, c, d, keep, nn)
|
||
RT.block_track(gt, l, a, b, c, d, RT.CLR + sh + ww / 2.0, nn)
|
||
rr = RT.VIA_D / 2.0 + halfv
|
||
rt = RT.VIA_D / 2.0 + RT.CLR + sh
|
||
for l in RT.LAY:
|
||
g.block_both(l, vx - rr, vy - rr, vx + rr, vy + rr, 0.0, net=q[7])
|
||
gt.block_rect(l, vx - rt, vy - rt, vx + rt, vy + rt, net=q[7])
|
||
bypad[q[7]] = [o for o in bypad[q[7]] if o is not q]
|
||
bypad[q[7]].append([q[0], 'fan:%s' % q[1], vx, vy, 0.3, 0.3, 1, q[7], 'VIA']) # 'VIA'：孔心两层都是出口
|
||
ok += 1
|
||
return out_s, out_v, ok, fail
|
||
|
||
|
||
def _p2s(px, py, x0, y0, x1, y1):
|
||
dx, dy = x1 - x0, y1 - y0
|
||
L2 = dx * dx + dy * dy
|
||
t = 0.0 if L2 < 1e-12 else max(0.0, min(1.0, ((px - x0) * dx + (py - y0) * dy) / L2))
|
||
return math.hypot(px - (x0 + t * dx), py - (y0 + t * dy))
|
||
|
||
|
||
def _seg_seg(a, b):
|
||
u"""两段中心线之间的最短距离（不相交时）。"""
|
||
return min(_p2s(a[1], a[2], b[1], b[2], b[3], b[4]), _p2s(a[3], a[4], b[1], b[2], b[3], b[4]),
|
||
_p2s(b[1], b[2], a[1], a[2], a[3], a[4]), _p2s(b[3], b[4], a[1], a[2], a[3], a[4]))
|
||
|
||
|
||
def _seg_rect_gap(s, r):
|
||
u"""线段（中心线）到矩形的最短距离（相交为 0）。"""
|
||
def p2s(px, py, x0, y0, x1, y1):
|
||
dx, dy = x1 - x0, y1 - y0
|
||
L2 = dx * dx + dy * dy
|
||
t = 0.0 if L2 < 1e-12 else max(0.0, min(1.0, ((px - x0) * dx + (py - y0) * dy) / L2))
|
||
return math.hypot(px - (x0 + t * dx), py - (y0 + t * dy))
|
||
x0, y0, x1, y1 = s[1], s[2], s[3], s[4]
|
||
n = max(2, int(math.hypot(x1 - x0, y1 - y0) / 0.02))
|
||
best = 1e9
|
||
for k in range(n + 1):
|
||
t = k / float(n)
|
||
px, py = x0 + (x1 - x0) * t, y0 + (y1 - y0) * t
|
||
dx = max(r[0] - px, px - r[2], 0.0)
|
||
dy = max(r[1] - py, py - r[3], 0.0)
|
||
best = min(best, math.hypot(dx, dy))
|
||
return best
|
||
|
||
|
||
# ⛔ 上行 / USB6 两对的脚在 U32 **西**侧，去处却在东边（J23 / U20）。首轮 A* 从 L4 绕 U32 南边，
|
||
# 贴着南沿把 strap 脚（CFGSEL0/1、NONREM0/1、HUB_RST、VBUS_DET）全封死。
|
||
# ⇒ 布这两对时在 U32 的南 / 北 / 东三面围一道**只对它们**的 L4 栅栏（离焊盘 3 mm），
|
||
# 逼它们在西侧打孔上 L1、从芯片顶上过去（L1 在走廊 2 是空的）。
|
||
FENCED_PAIRS = ('USB6', 'USBUP')
|
||
FENCE_OUT = 3.0
|
||
FENCE_IN = 0.9 # 栅栏西端离西排焊盘外沿多远（给西排脚自己的引出脚留地方）
|
||
|
||
|
||
def u32_fence(pads):
|
||
ps = [q for q in pads if q[0] == 'U32' and q[7] != 'GND']
|
||
x0 = min(q[2] - q[4] / 2 for q in ps)
|
||
y0 = min(q[3] - q[5] / 2 for q in ps)
|
||
x1 = max(q[2] + q[4] / 2 for q in ps)
|
||
y1 = max(q[3] + q[5] / 2 for q in ps)
|
||
xw = x0 + FENCE_IN
|
||
return [(2, (xw, y0 - FENCE_OUT, x1 + FENCE_OUT, y0 + FENCE_IN)), # 南
|
||
(2, (xw, y1 - FENCE_IN, x1 + FENCE_OUT, y1 + FENCE_OUT)), # 北
|
||
(2, (x1 - FENCE_IN, y0 - FENCE_OUT, x1 + FENCE_OUT, y1 + FENCE_OUT))] # 东
|
||
|
||
|
||
def route_pairs(bypad, pads, segs, vias, board_vias, logs):
|
||
u"""七对 D±：DP 先布，DM 贴着它布。返回新布的 (segs, vias)。"""
|
||
out_s, out_v = [], []
|
||
pad_pen = RT.PAD_PEN
|
||
RT.PAD_PEN = DP_PAD_PEN
|
||
# ⛔ D± **不吃层方向偏好**（2026-09-10 实测）：开了 ×2 之后 USBUP 长度差 3.5 → 5.7 mm（超 3.81 规则）、
|
||
# USB6 / USBUP 过孔每根 2 → 4 个 —— 差分对有自己的拓扑规则（DP 先、DM 贴着），方向偏好只会逼它多换层。
|
||
# 这里临时八方向同价，布完恢复；其余网照样按 L1 横 / L4 纵。
|
||
layer_dir = RT.LAYER_DIR
|
||
RT.LAYER_DIR = {}
|
||
fence = u32_fence(pads)
|
||
try:
|
||
for k, name in enumerate(PAIR_ORDER):
|
||
dp, dm = PAIRS[name]
|
||
later = [q for nm in PAIR_ORDER[k + 1:] for n in PAIRS[nm] for q in bypad.get(n, [])]
|
||
fc = fence if name in FENCED_PAIRS else ()
|
||
# ⛔ 上行 / USB6 的 DP：L4 上除了两端脚附近 3 mm 全收过路费，逼它上 L1 走空走廊。
|
||
# 第二轮只有栅栏时，它从栅栏西南角绕出去、贴着 J37 底下往东，照样把 strap 脚南路堵了。
|
||
# DM 不用单独处理：它贴着 DP 的带子走。
|
||
lp = None
|
||
if name in FENCED_PAIRS:
|
||
lp = {1: [(0.0, 0.0, B.BW, B.BH)],
|
||
2: [RT.pad_rect(q, 3.0) for q in bypad.get(dp, []) + bypad.get(dm, [])]}
|
||
s, v = route_one(dp, bypad.get(dp, []), DIFF_W, pads, segs + out_s, vias + out_v,
|
||
board_vias, logs, pen_pads=later + bypad.get(dm, []), fence=fc, hug=lp)
|
||
out_s += s
|
||
out_v += v
|
||
band = None
|
||
if s:
|
||
band = {1: [], 2: []}
|
||
for q in s:
|
||
band[q[0]].append(_seg_box(q, HUG_BAND))
|
||
for (vx, vy, _n) in v:
|
||
for l in RT.LAY:
|
||
band[l].append((vx - 1.2, vy - 1.2, vx + 1.2, vy + 1.2))
|
||
for q in bypad.get(dm, []):
|
||
r = RT.pad_rect(q, HUG_PAD)
|
||
for l in RT.LAY:
|
||
band[l].append(r)
|
||
s2, v2 = route_one(dm, bypad.get(dm, []), DIFF_W, pads, segs + out_s, vias + out_v,
|
||
board_vias, logs, pen_pads=later, hug=band, fence=fc)
|
||
out_s += s2
|
||
out_v += v2
|
||
finally:
|
||
RT.PAD_PEN = pad_pen
|
||
RT.LAYER_DIR = layer_dir
|
||
return out_s, out_v
|
||
|
||
|
||
# ── D± 换层处的 GND 回流孔 / 过孔上限（2026-09-11 第 4 阶段）─────────────────────
|
||
# 双地叠层：L1 的线参考 L2 地、L4 的线参考 L3 地。D± 一换层，回流也要从 L2 换到 L3 —— 旁边没有地孔，
|
||
# 回流只能绕到远处的缝合孔，环路面积陡增。⇒ 同一对、1.6 mm 以内的换层孔算一处，就近补一颗 GND 孔。
|
||
# 回流孔离**最近**那颗换层孔 ≤ DP_RET_R、离最远那颗 ≤ DP_RET_FAR（中心距）。
|
||
# 第一版要求离两颗都 ≤ 1.7：一对并排的孔相距 1.0，而占用图让新孔离每颗 D± 孔 ≥ 0.92（方框），
|
||
# 空位只在一对的侧面 ⇒ 离远的那颗 ~2 mm，七处有四处落不下（静态校验实测）。
|
||
DP_RET_R = 1.3
|
||
DP_RET_FAR = 2.6
|
||
DP_MAX_VIAS = 4 # 每根 D± 的过孔上限（超了记入未完成）
|
||
|
||
|
||
def dp_return_vias(pads, segs, vias, board_vias, logs):
|
||
halfv = RT.VIA_D / 2.0 + RT.CLR
|
||
g, _gt, _o = grid_now(pads, halfv, segs, vias, board_vias)
|
||
out = []
|
||
for name, dp, dm in RB.PAIRS:
|
||
groups = []
|
||
for v in [v for v in vias if v[2] in (dp, dm)]:
|
||
for gr in groups:
|
||
if any(math.hypot(v[0] - u[0], v[1] - u[1]) < 1.6 for u in gr):
|
||
gr.append(v)
|
||
break
|
||
else:
|
||
groups.append([v])
|
||
for gr in groups:
|
||
cx = sum(v[0] for v in gr) / len(gr)
|
||
cy = sum(v[1] for v in gr) / len(gr)
|
||
# 已经放下的回流孔也满足这一处 ⇒ 共用（上行 / USB6 两组西侧孔就共用一颗，
|
||
# 各放一颗的话两孔中心距 0.5，钻孔间距不够，dedupe 还会悄悄删掉一颗）
|
||
if any(min(math.hypot(o[0] - v[0], o[1] - v[1]) for v in gr) <= DP_RET_R and
|
||
max(math.hypot(o[0] - v[0], o[1] - v[1]) for v in gr) <= DP_RET_FAR for o in out):
|
||
continue
|
||
ci, cj = RT.gx(cx), RT.gy(cy)
|
||
rr = int(math.ceil((DP_RET_FAR + 0.5) / RT.G))
|
||
best = None
|
||
for i in range(max(0, ci - rr), min(RT.NX - 1, ci + rr) + 1):
|
||
for j in range(max(0, cj - rr), min(RT.NY - 1, cj + rr) + 1):
|
||
x, y = RT.wx(i), RT.wy(j)
|
||
ds = [math.hypot(x - v[0], y - v[1]) for v in gr]
|
||
if min(ds) > DP_RET_R or max(ds) > DP_RET_FAR:
|
||
continue
|
||
if not g.free_via(i, j, 'GND'):
|
||
continue
|
||
if any(math.hypot(x - o[0], y - o[1]) < RT.VIA_D + 0.15 for o in out):
|
||
continue
|
||
key = (min(ds), sum(ds))
|
||
if best is None or key < best[0]:
|
||
best = (key, x, y)
|
||
if best is None:
|
||
logs.append(u'%s: 换层处 (%.2f, %.2f) 旁边落不下 GND 回流孔' % (name, cx, cy))
|
||
continue
|
||
_d, x, y = best
|
||
out.append((round(x, 3), round(y, 3), 'GND'))
|
||
r = RT.VIA_D / 2.0 + halfv
|
||
for l in RT.LAY:
|
||
g.block_both(l, x - r, y - r, x + r, y + r, 0.0, net='GND')
|
||
return out
|
||
|
||
|
||
def dp_via_limit(vias, logs):
|
||
for _name, dp, dm in RB.PAIRS:
|
||
for net in (dp, dm):
|
||
n = sum(1 for v in vias if v[2] == net)
|
||
if n > DP_MAX_VIAS:
|
||
logs.append(u'%s: 过孔 %d 个，超过上限 %d' % (net, n, DP_MAX_VIAS))
|
||
|
||
|
||
def is_ep(p):
|
||
return p[7] == 'GND' and min(p[4], p[5]) >= EP_MIN
|
||
|
||
|
||
def plane_vias(pads, segs, vias, board_vias, logs, skip, which, done):
|
||
u"""GND / +12V 平面网：每只焊盘一个过孔（大 GND 焊盘在盘里打孔阵）。
|
||
|
||
`which='early'`：+12V 焊盘 + GND 散热 / 外壳盘（盘内孔阵，不占任何人的出口），布信号之前做。
|
||
`which='late'`：其余 GND 贴片焊盘，**布完信号之后**做。
|
||
⛔ 首轮是全部放在信号之前：插槽 1 mm 间距的针排里，GND 脚的孔一落就把隔壁信号脚的出口
|
||
夹成 0.4 mm（0.15 的线都过不去）—— I²C / VDAC / EFUSE_EN / PRSNT 几十条全报「没布通」。
|
||
`done` 记已处理的焊盘（早段孔阵没打上的，晚段按普通焊盘再试）。
|
||
"""
|
||
halfv = RT.VIA_D / 2.0 + RT.CLR
|
||
g, gt, others = grid_now(pads, halfv, segs, vias, board_vias)
|
||
m = B.l1_12v_rects()[0]
|
||
land = (m[0] + V12_LAND, m[1] + V12_LAND, m[2] - V12_LAND, m[3] - V12_LAND)
|
||
out_s, out_v = [], []
|
||
cnt = {'GND': 0, '+12V': 0, '+3V3': 0, 'EP': 0}
|
||
sh = RT.W_DEFAULT / 2.0
|
||
|
||
def occupy(ss, vx, vy, net, w):
|
||
keep = halfv + w / 2.0
|
||
for (l, a, b, c, d, ww, _nn) in ss:
|
||
RT.block_track(g, l, a, b, c, d, keep, net)
|
||
RT.block_track(gt, l, a, b, c, d, RT.CLR + sh + ww / 2.0, net)
|
||
r = RT.VIA_D / 2.0 + halfv
|
||
rt = RT.VIA_D / 2.0 + RT.CLR + sh
|
||
for l in RT.LAY:
|
||
g.block_both(l, vx - r, vy - r, vx + r, vy + r, 0.0, net=net)
|
||
gt.block_rect(l, vx - rt, vy - rt, vx + rt, vy + rt, net=net)
|
||
|
||
for p in pads:
|
||
net = p[7]
|
||
if net not in PLANE_NETS or p[6] not in RT.LAY:
|
||
continue
|
||
key = (p[0], str(p[1]))
|
||
if str(p[1]).endswith(TH_SUFFIX) or key in TH_KEYS or key in skip:
|
||
continue
|
||
if net == '+12V' and p[6] == 1:
|
||
continue # 槽上的 12V 针本来就在 L1 大铜里
|
||
if key in done:
|
||
continue
|
||
# 早段：+12V、散热盘孔阵、以及几颗扇出芯片自己的 +3V3 脚（它们最容易被信号封住）
|
||
early_3v3 = net == '+3V3' and p[0] in FANOUT_REFS
|
||
if which == 'early' and not (net == '+12V' or is_ep(p) or early_3v3):
|
||
continue
|
||
if which == 'late' and net not in LATE_PLANE_NETS:
|
||
continue
|
||
if which == 'early' and is_ep(p):
|
||
x0, y0, x1, y1 = RT.pad_rect(p)
|
||
nx = max(1, int((x1 - x0 - 2 * EP_EDGE) / EP_PITCH) + 1)
|
||
ny = max(1, int((y1 - y0 - 2 * EP_EDGE) / EP_PITCH) + 1)
|
||
nx, ny = min(nx, 3), min(ny, 3)
|
||
got = 0
|
||
for a in range(nx):
|
||
for b in range(ny):
|
||
vx = p[2] if nx == 1 else x0 + EP_EDGE + a * (x1 - x0 - 2 * EP_EDGE) / (nx - 1)
|
||
vy = p[3] if ny == 1 else y0 + EP_EDGE + b * (y1 - y0 - 2 * EP_EDGE) / (ny - 1)
|
||
i, j = RT.gx(vx), RT.gy(vy)
|
||
if g.free_via(i, j, 'GND'):
|
||
out_v.append((round(vx, 3), round(vy, 3), 'GND'))
|
||
occupy([], vx, vy, 'GND', 0.0)
|
||
got += 1
|
||
if got:
|
||
cnt['EP'] += 1
|
||
done.add(key)
|
||
continue # 没打上的留给晚段按普通焊盘处理
|
||
w = max(RT.rule_min(net, {}), min(0.5 if net == '+12V' else 0.3, p[4], p[5]))
|
||
# ⛔ 落孔只看**过孔图**（free_via，两层都按过孔口径让开）。第一版还要求两层**导线图**都空，
|
||
# 而 L1 的 12V 大铜在导线图里是占着的 —— A1/A2/A6 里 40 多只 GND 脚因此全报「找不到落孔点」。
|
||
# GND 孔落进 12V 大铜是合法的：铺铜自己挖反焊盘。
|
||
cand = [nd for nd in RT.pad_nodes(g, p, halfv, others.get(p[6], []), w / 2.0, gt)
|
||
if g.free_via(nd[1], nd[2], net)
|
||
and (net != '+12V' or (land[0] <= RT.wx(nd[1]) <= land[2]
|
||
and land[1] <= RT.wy(nd[2]) <= land[3]))]
|
||
if not cand:
|
||
logs.append(u'%s: %s.%s 找不到落过孔的地方' % (net, p[0], p[1]))
|
||
continue
|
||
nd = cand[0]
|
||
vx, vy = RT.wx(nd[1]), RT.wy(nd[2])
|
||
ss = RT.stub_emit(p, vx, vy, others.get(p[6], []), w / 2.0, w, net, gt)
|
||
out_s += ss
|
||
out_v.append((vx, vy, net))
|
||
occupy(ss, vx, vy, net, w)
|
||
cnt[net] += 1
|
||
done.add(key)
|
||
print(u' 平面网扇出（%s）：GND %d / +3V3 %d 只脚各一孔、散热/外壳盘 %d 块打孔阵、+12V %d 只脚；共 %d 孔'
|
||
% (which, cnt['GND'], cnt['+3V3'], cnt['EP'], cnt['+12V'], len(out_v)))
|
||
return out_s, out_v
|
||
|
||
|
||
# ── 主流程 ───────────────────────────────────────────────────────────────
|
||
def plan_all(priority=()):
|
||
pads = load_pads()
|
||
board_vias = load_board_vias()
|
||
print(u'板上已有过孔 %d 个；通孔焊盘 %d 只（L4 可布 + L1 障碍）' % (len(board_vias), len(TH_KEYS)))
|
||
segs, vias, logs = [], [], []
|
||
pm_net = {(q[0], str(q[1])): q[7] for q in pads}
|
||
NOVIA_NETS.clear()
|
||
NOVIA_NETS.update(NOVIA_NAMED)
|
||
NOVIA_NETS.update(pm_net[k] for k in NOVIA_PINS if pm_net.get(k))
|
||
print(u' 只走 L4 的敏感网：%s（+ Kelvin 两条）' % ' '.join(sorted(NOVIA_NETS)))
|
||
|
||
ks, kv = kelvin(pads, segs, vias, board_vias, logs)
|
||
segs += ks
|
||
vias += kv
|
||
print(u' Kelvin：%d 段 / %d 孔' % (len(ks), len(kv)))
|
||
hs, hv = v12_handoff(pads)
|
||
segs += hs
|
||
vias += hv
|
||
print(u' 9 A 上 L1：Rs6.2 西侧铜块 + %d 个过孔' % len(hv))
|
||
|
||
js, jdone = j23_bridges(pads)
|
||
segs += js
|
||
print(u' J23 同名 D± 脚两座桥：%d 段（DP 南绕 / DM 北绕）' % len(js))
|
||
ns, nv, ndone, nvirt = u32_north(pads, segs, vias)
|
||
segs += ns
|
||
vias += nv
|
||
jdone |= ndone
|
||
print(u' U32 北沿 5/10 供电 + 去耦、13/19 接散热盘：%d 段 / %d 孔（按构造画）' % (len(ns), len(nv)))
|
||
cs_, cv, cdone, cvirt = dp_construct(pads, segs, vias)
|
||
segs += cs_
|
||
vias += cv
|
||
jdone |= cdone
|
||
nvirt = nvirt + cvirt
|
||
print(u' D± 构造（USB1/2/3 北上直进、USB4/5 东绕、上行/USB6 西侧上 L1）：%d 段 / %d 孔' % (len(cs_), len(cv)))
|
||
ws, wdone = u32_west(pads, segs, vias) # 要在 route_pairs / dp_return_vias 之前：回流孔曾落进晶振通道
|
||
segs += ws
|
||
jdone |= wdone
|
||
print(u' U32 西沿 60~63 脚（晶振 / VDD18PLL / RBIAS）：%d 段（按构造画、只在 L4）' % len(ws))
|
||
# ⚠ 默认**不开**（第 24 轮：信号网 35 → 38、预判 DRC 冒出 2 处，SDA 从直出末端照样出不去 —— 卡的不只是出脚）
|
||
if '--u13-fan' in sys.argv:
|
||
fs, fdone, fvirt = u13_fan(pads, segs, vias)
|
||
segs += fs
|
||
jdone |= fdone
|
||
nvirt = nvirt + fvirt
|
||
print(u' U13 东列 3/4 脚（INA_ALERT / SDA）平直东出：%d 段，落点 %d 个' % (len(fs), len(fvirt)))
|
||
# U13 东列三个网整体构造出线（2026-09-11 第 26 轮起默认开，`--no-u13-esc` 关；接替 --u13-fan）
|
||
if '--no-u13-esc' not in sys.argv and '--u13-fan' not in sys.argv:
|
||
es, ev, edone, evirt = u13_esc(pads, segs, vias + [tuple(v[:3]) for v in board_vias])
|
||
segs += es
|
||
vias += ev
|
||
jdone |= edone
|
||
nvirt = nvirt + evirt
|
||
print(u' U13 东列 SCL / SDA / INA_ALERT 构造出线：%d 段 / %d 孔，落点 %d 个' % (len(es), len(ev), len(evirt)))
|
||
# ⚠ 默认**不开**（2026-09-11 第 21 轮：+3V3 真连通之后信号网 37 → 44，比布线器自己的走法差）；`--v3-trunk` 才启用。
|
||
# 诊断开关（--3v3-plane / --3v3-skip）下 +3V3 不走线，也别构造。
|
||
if '--v3-trunk' in sys.argv and '+3V3' not in PLANE_NETS and '--3v3-skip' not in sys.argv:
|
||
ts, tv, tdone, tvirt = v3_trunk(pads, segs, vias)
|
||
segs += ts
|
||
vias += tv
|
||
jdone |= tdone
|
||
nvirt = nvirt + tvirt
|
||
print(u' +3V3 定点构造（U35 东侧旁路 + U13 东南进）：%d 段 / %d 孔，WALL 落点 %d 个' % (len(ts), len(tv), len(tvirt)))
|
||
|
||
kel = {a for a, _b, _w in KELVIN} # U13.9/.10 已由专线接好
|
||
bypad = {}
|
||
for p in pads:
|
||
if not p[7] or p[7] in PLANE_NETS or str(p[1]).endswith(TH_SUFFIX):
|
||
continue
|
||
if p[7] == '+3V3' and '--3v3-skip' in sys.argv: # 诊断开关，见 LATE_PLANE_NETS 处
|
||
continue
|
||
if (p[0], str(p[1])) in kel or (p[0], str(p[1])) in jdone:
|
||
continue
|
||
bypad.setdefault(p[7], []).append(p)
|
||
for v in nvirt:
|
||
bypad.setdefault(v[7], []).append(v)
|
||
|
||
ds, dv = route_pairs(bypad, pads, segs, vias, board_vias, logs)
|
||
segs += ds
|
||
vias += dv
|
||
print(u' D± 七对：%d 段 / %d 孔' % (len(ds), len(dv)))
|
||
rv = dp_return_vias(pads, segs, vias, board_vias, logs)
|
||
vias += rv
|
||
print(u' D± 换层处 GND 回流孔：%d 颗' % len(rv))
|
||
if '--dp-only' in sys.argv:
|
||
dp_via_limit(vias, logs)
|
||
return segs, vias, logs
|
||
|
||
skip = set(kel) | {('Rs6', '2')} | set(jdone) # 构造里已接地的脚（U32.13/19、C750/C747 地脚）不再单打孔
|
||
done = set()
|
||
ps, pv = plane_vias(pads, segs, vias, board_vias, logs, skip, 'early', done)
|
||
segs += ps
|
||
vias += pv
|
||
GND_PEN_PADS[:] = [q for q in pads if q[7] in LATE_PLANE_NETS and q[6] in RT.LAY
|
||
and (q[0], str(q[1])) not in done and (q[0], str(q[1])) not in TH_KEYS
|
||
and not str(q[1]).endswith(TH_SUFFIX)]
|
||
fs, fv, fok, ffail = fanout(pads, bypad, segs, vias, board_vias, logs)
|
||
segs += fs
|
||
vias += fv
|
||
print(u' 扇出上 L1（%s）：%d 只脚打孔，%d 只没落点（留给 A* 直接接）'
|
||
% (' '.join(FANOUT_REFS), fok, ffail))
|
||
|
||
rest = set(bypad) - set(DP_NETS)
|
||
RT.AUTO_CACHE.clear()
|
||
blocked = [('#ant', r) for r in (_KEEP[0] or keep_rects())] + [('+12V', V12_PATCH)]
|
||
direct_nets = rest & set(priority) if priority else rest
|
||
dsegs, merged = RT.direct_links(pads, {n: bypad[n] for n in direct_nets}, segs, vias,
|
||
blocked_rects=blocked)
|
||
segs += dsegs
|
||
for net, groups in merged.items():
|
||
drop = set()
|
||
for group in groups:
|
||
drop |= set(list(group)[1:])
|
||
bypad[net] = [q for q in bypad[net] if (q[0], q[1]) not in drop]
|
||
print(u' 直连：%d 段 / %d 个网络' % (len(dsegs), len(merged)))
|
||
# U32 的本地网（晶振 / RBIAS / VDD18PLL / VDD18 / strap / HUB_RST / VBUS_DET）：第六轮它们的脚全被
|
||
# 先布的长信号在 U32 西侧落的孔、南边拉的线堵住，而要连的件就在一两毫米外 ⇒ 在长信号之前先布。
|
||
u32_local = set(n for n in rest if n not in POWER_LATE and n not in CHAIN_NETS
|
||
and any(q[0] == 'U32' for q in bypad.get(n, [])))
|
||
fixed_s, fixed_v = len(segs), len(vias)
|
||
# 四段：输入链（短、宽、有专属条带）→ U32 本地网 → 普通信号 → 电源（最后布，脚一直收过路费）
|
||
# 2026-09-11 起多一段 EARLY_NETS（U32 本地网之后、普通信号之前）
|
||
early = (set(EARLY_NETS) & rest) - u32_local
|
||
if '--no-early' in sys.argv: # 对照：INA_ALERT 回到普通信号那一段
|
||
early = set()
|
||
phases = [set(CHAIN_NETS) & rest, u32_local, early, set(), set(POWER_LATE) & rest]
|
||
phases[3] = rest - phases[0] - phases[1] - phases[2] - phases[4]
|
||
if '--pf' in sys.argv:
|
||
LATER_PEN_PADS[:] = [q for n in rest - u32_local for q in bypad.get(n, [])]
|
||
logs += RT.route_groups(bypad, pads, segs, vias, board_vias, {}, priority=priority,
|
||
only=u32_local)
|
||
print(u' U32 本地网（%d 个）先布：失败 %d 条' % (len(u32_local), len(logs)))
|
||
fixed_s, fixed_v = len(segs), len(vias)
|
||
rest = rest - u32_local
|
||
# 协商式拥塞布线（router.pf_solve，PathFinder）：每轮所有网重布、被多网压着的格点逐轮涨价，
|
||
# 直到有人让路。第四轮的失败已经不是「脚出不来」而是贪心抢通道（长网先布、走最短路，
|
||
# 走廊 3 和槽体西段 x 36~43 很快被占光）—— 正是 PathFinder 要解决的那一类。
|
||
if '--pf-iters' in sys.argv:
|
||
RT.PF_ITERS = int(sys.argv[sys.argv.index('--pf-iters') + 1])
|
||
LATER_PEN_PADS[:] = []
|
||
logs += RT.pf_solve({n: bypad[n] for n in rest if n in bypad}, pads, segs, vias,
|
||
board_vias, {}, fixed_s, fixed_v)
|
||
print(u' PathFinder：失败 %d 条' % len(logs))
|
||
phases = []
|
||
for k, ph in enumerate(phases):
|
||
later = set().union(*phases[k + 1:]) if k + 1 < len(phases) else set()
|
||
LATER_PEN_PADS[:] = [q for n in later for q in bypad.get(n, [])]
|
||
n0 = len(logs)
|
||
logs += RT.route_groups(bypad, pads, segs, vias, board_vias, {}, priority=priority, only=ph)
|
||
print(u' 第 %d 段（%d 个网）：失败 %d 条' % (k + 1, len(ph), len(logs) - n0))
|
||
LATER_PEN_PADS[:] = []
|
||
if logs and '--repair' in sys.argv:
|
||
print(u' 首轮 %d 条没搞定，进入拆线重布' % len(logs))
|
||
segs, vias, logs = rip_repair(bypad, pads, segs, vias, logs, board_vias, rest, fixed_s, fixed_v)
|
||
GND_PEN_PADS[:] = []
|
||
ps, pv = plane_vias(pads, segs, vias, board_vias, logs, skip, 'late', done)
|
||
segs += ps
|
||
vias += pv
|
||
gs, nres = gnd_rescue(pads, segs, vias, logs, done, blocked)
|
||
segs += gs
|
||
print(u' GND 打不上孔的脚：直连到邻近已接地焊盘救回 %d 只（%d 段）' % (nres, len(gs)))
|
||
segs, vias = RT.dedupe_vias(segs, vias)
|
||
dp_via_limit(vias, logs)
|
||
for m in RT.check_connected(check_pads(pads), segs, vias):
|
||
if m not in logs:
|
||
logs.append(u'[连通性] ' + m)
|
||
return segs, vias, logs
|
||
|
||
|
||
GND_RESCUE_R = 2.6 # 找「邻近已接地焊盘」的半径（mm，同层）
|
||
|
||
|
||
def gnd_rescue(pads, segs, vias, logs, done, blocked):
|
||
u"""晚段打不上孔的 GND 脚：用 router.direct_links 直连到邻近**已接地**的同层焊盘（原地删掉救回的日志）。
|
||
|
||
插槽针排里两只相邻的 GND 脚（1 mm 间距、缝 0.3）最常见：隔壁那只有孔，直连一段就接上了。
|
||
「已接地」= 已有平面孔（done）或通孔焊盘（本来就穿到内层地）。
|
||
"""
|
||
tag = u'找不到落过孔的地方'
|
||
anchor = set(done) | TH_KEYS
|
||
out_s, nok = [], 0
|
||
for net in LATE_PLANE_NETS: # 现在只有 GND（+3V3 已不是平面网）
|
||
head = net + ': '
|
||
fl = [m for m in logs if m.startswith(head) and tag in m]
|
||
if not fl:
|
||
continue
|
||
fkeys = set()
|
||
for m in fl:
|
||
ref, pin = m[len(head):].split(' ')[0].rsplit('.', 1)
|
||
fkeys.add((ref, pin))
|
||
fpads = [q for q in pads if (q[0], str(q[1])) in fkeys and q[6] in RT.LAY]
|
||
near = [q for q in pads if q[7] == net and q[6] in RT.LAY and (q[0], str(q[1])) in anchor
|
||
and not str(q[1]).endswith(TH_SUFFIX)
|
||
and any(q[6] == f[6] and abs(q[2] - f[2]) < GND_RESCUE_R
|
||
and abs(q[3] - f[3]) < GND_RESCUE_R for f in fpads)]
|
||
dsegs, merged = RT.direct_links(pads, {net: fpads + near}, segs + out_s, vias,
|
||
blocked_rects=blocked)
|
||
ok = set()
|
||
for grp in merged.get(net, []):
|
||
keys = set((k[0], str(k[1])) for k in grp)
|
||
if keys & anchor:
|
||
ok |= keys & fkeys
|
||
logs[:] = [m for m in logs
|
||
if not (m in fl and tuple(m[len(head):].split(' ')[0].rsplit('.', 1)) in ok)]
|
||
out_s += dsegs
|
||
nok += len(ok)
|
||
return out_s, nok
|
||
|
||
|
||
def check_pads(pads):
|
||
u"""连通性判据用的焊盘：去掉 L1 的通孔副本、L1 大铜里的 12V 针、单脚网。"""
|
||
cnt = {}
|
||
for q in pads:
|
||
cnt[q[7]] = cnt.get(q[7], 0) + 1
|
||
return [q for q in pads if not str(q[1]).endswith(TH_SUFFIX)
|
||
and not (q[7] == '+12V' and q[6] == 1) and cnt.get(q[7], 0) >= 2]
|
||
|
||
|
||
def rip_repair(bypad, pads, segs, vias, logs, board_vias, rest, fixed_s, fixed_v):
|
||
u"""`router.repair` 接到底板上：只交普通信号（D± / 平面网不拆），验收用 check_pads。"""
|
||
import time
|
||
sub = {n: bypad[n] for n in rest if n in bypad}
|
||
chk_pads = [q for q in check_pads(pads) if q[7] in sub]
|
||
orig_chk, orig_rg = RT.check_connected, RT.route_groups
|
||
t0, n = time.time(), [0]
|
||
|
||
def chk(_pads, s, v):
|
||
return orig_chk(chk_pads, s, v)
|
||
|
||
def rg(*a, **k):
|
||
n[0] += 1
|
||
out = orig_rg(*a, **k)
|
||
print(u' 拆线重布 #%d：重布 %d 个网，失败 %d 条（累计 %.0f s）'
|
||
% (n[0], len(k.get('only') or ()), len(out), time.time() - t0))
|
||
sys.stdout.flush()
|
||
return out
|
||
|
||
RT.check_connected, RT.route_groups = chk, rg
|
||
try:
|
||
return RT.repair(sub, pads, segs, vias, logs, board_vias, {}, fixed_s, fixed_v)
|
||
finally:
|
||
RT.check_connected, RT.route_groups = orig_chk, orig_rg
|
||
|
||
|
||
def report(segs, vias, logs):
|
||
L = lambda s: math.hypot(s[3] - s[1], s[4] - s[2]) # noqa: E731
|
||
tot = sum(L(s) for s in segs)
|
||
top = sum(L(s) for s in segs if s[0] == 1)
|
||
print(u'导线 %d 段 / 总长 %.1f mm（L1 %.1f mm = %.0f%%）/ 过孔 %d（GND %d / +12V %d / 信号 %d）'
|
||
% (len(segs), tot, top, 100.0 * top / max(tot, 1e-9), len(vias),
|
||
sum(1 for v in vias if v[2] == 'GND'), sum(1 for v in vias if v[2] == '+12V'),
|
||
sum(1 for v in vias if v[2] not in PLANE_NETS)))
|
||
print(u'差分对实测铜长（含引出脚）/ 过孔数:')
|
||
for name, dp, dm in RB.PAIRS:
|
||
a = sum(L(s) for s in segs if s[6] == dp)
|
||
b = sum(L(s) for s in segs if s[6] == dm)
|
||
va = sum(1 for v in vias if v[2] == dp)
|
||
vb = sum(1 for v in vias if v[2] == dm)
|
||
print(u' %-6s DP %5.1f mm / %d 孔 DM %5.1f mm / %d 孔 差 %.1f mm'
|
||
% (name, a, va, b, vb, abs(a - b)))
|
||
if logs:
|
||
print(u'[!] %d 条没搞定:' % len(logs))
|
||
for m in logs[:40]:
|
||
print(u' ' + m)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
if '--clear' in sys.argv:
|
||
RT.clear_mine()
|
||
sys.exit(0)
|
||
if '--snapshot-vias' in sys.argv:
|
||
print(u'底板既有过孔快照：%d 个 -> %s' % (len(load_board_vias()), BOARD_VIAS))
|
||
sys.exit(0)
|
||
c = json.load(io.open(CACHE, encoding='utf-8')) if os.path.exists(CACHE) else {}
|
||
cache_ok = (c.get('schema') == CACHE_SCHEMA and c.get('slot_rot') == B.SLOT_ROT and
|
||
c.get('usb_slot_ref') == {str(k): v for k, v in B.USB_SLOT_REF.items()})
|
||
if '--replan' not in sys.argv and cache_ok:
|
||
segs, vias, logs = [tuple(s) for s in c['segs']], [tuple(v) for v in c['vias']], c['logs']
|
||
print(u'（用缓存 _base_routes.json）')
|
||
elif '--replan' not in sys.argv:
|
||
sys.exit(u'!! 没有 4 层版缓存（schema %d）；布线要在服务器上算：.claude/r2/remote_route.ps1'
|
||
% CACHE_SCHEMA)
|
||
else:
|
||
best, prio = None, set()
|
||
if '--priority-cache' in sys.argv and cache_ok:
|
||
prio = set(RT._msg_net(m) for m in c.get('logs', []))
|
||
print(u'（用上轮 %d 条失败记录优先排网）' % len(c.get('logs', [])))
|
||
if '--passes' in sys.argv:
|
||
RT.PASSES = int(sys.argv[sys.argv.index('--passes') + 1])
|
||
for it in range(RT.PASSES):
|
||
segs, vias, logs = plan_all(prio)
|
||
print(u' 第 %d 轮：%d 条没搞定' % (it + 1, len(logs)))
|
||
if best is None or len(logs) < len(best[2]):
|
||
best = (segs, vias, logs)
|
||
if not logs:
|
||
break
|
||
prio |= set(RT._msg_net(m) for m in logs)
|
||
segs, vias, logs = best
|
||
if '--dp-only' not in sys.argv:
|
||
io.open(CACHE, 'w', encoding='utf-8').write(json.dumps({
|
||
'schema': CACHE_SCHEMA, 'layers': B.LAYERS, 'slot_rot': B.SLOT_ROT,
|
||
'usb_slot_ref': B.USB_SLOT_REF, 'v12_patch': V12_PATCH, 'u20_remap': u20_remap_name(),
|
||
'segs': segs, 'vias': vias, 'logs': logs}, ensure_ascii=False))
|
||
report(segs, vias, logs)
|
||
if '--push' in sys.argv:
|
||
if json.load(io.open(CACHE, encoding='utf-8')).get('u20_remap'):
|
||
sys.exit(u'!! 这份缓存是 U20 引脚重分配的试算（u20_remap），原理图 / 板上焊盘网名都没改，不许下发')
|
||
# 默认仍拒绝下发不完整路由；`--force` 是 2026-09-10 用户选定的收尾方式：
|
||
# 先把最好的一版下发，剩下的在客户端手工补 / 逐条构造。
|
||
if logs and '--force' not in sys.argv:
|
||
sys.exit(u'!! 仍有 %d 条未布通，拒绝下发不完整路由（确认要先下发再手补，加 --force）' % len(logs))
|
||
if logs:
|
||
print(u'⚠ --force：带着 %d 条未完成下发' % len(logs))
|
||
RT.push(segs, vias)
|
||
# 记下「板上现在是哪一版」：过孔快照按它认布线孔（缓存可能已被新的服务器结果换掉、还没下发）
|
||
io.open(ONBOARD, 'w', encoding='utf-8').write(io.open(CACHE, encoding='utf-8').read())
|
||
print(u' 板上版本已记到 %s' % os.path.basename(ONBOARD))
|