272 行
13 KiB
Python
272 行
13 KiB
Python
# -*- coding: utf-8 -*-
|
||
u"""服务器上单独布 UP 对（2026-09-11 混合布线收尾）：以板上现有铜为障碍，从预布两端的孔出发，只走 L1/L4。
|
||
|
||
DCDC_ROUTE_SERVER=1 /root/pypy/bin/pypy3 .claude/r2/up_route.py [--grid 0.125] [--pre-only] [--free-3v3hub] [--centerline]
|
||
读 _board_for_up.json（板上快照）+ _base_preroute_0911.json（UP 两端到孔的预布段），写 _up_route.out.json
|
||
|
||
两种布法：
|
||
* 默认 = 照 route_base.route_pairs 的 USBUP：DP 先布，DM 贴着 DP 的带子布。
|
||
实测（2026-09-11）DP 总抢 J37 东端槽针与外壳盘之间 ~1.2 mm 的缝，DM 跟不进去就到处换层：DM 10~12 孔，不能用。
|
||
* `--centerline` = 整对当一根宽线（外包 0.78 = 两根 0.28 + 对内 0.22）只在 L1 上布，再向两侧各偏 0.25 劈成 DP / DM，
|
||
两端各用一小段接回预布孔。A* 保证找到的通道本来就放得下一对；中间不换层，所以两根都只有预布那两颗孔。
|
||
对内中心距 0.5：UP_DP–UP_DM 的 net-by-net 规则 USBPAIR 要 0.2 mm（第 17 轮对内 7.3 mil 报过错）。
|
||
"""
|
||
import io
|
||
import json
|
||
import math
|
||
import os
|
||
import sys
|
||
|
||
if os.environ.get('DCDC_ROUTE_SERVER') != '1':
|
||
sys.exit(u'!! 布线运算只在服务器上跑（DCDC_ROUTE_SERVER=1），见 CLAUDE.md')
|
||
if '--grid' not in sys.argv:
|
||
sys.argv += ['--grid', '0.125']
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
sys.path.insert(0, os.path.dirname(HERE))
|
||
sys.path.insert(0, HERE)
|
||
import route_base as R # noqa: E402
|
||
|
||
RT = R.RT
|
||
RT.VIA_LAUNCH_BOTH = True
|
||
UP = ('UP_DP', 'UP_DM')
|
||
EXTRA_FENCE = [] # [(层, (x0, y0, x1, y1))]：中心线额外禁区（fix3.py：J37 北排上方给 J37.19 的 +5V 让路）
|
||
PITCH = 0.5 # 对内中心距
|
||
if '--pitch' in sys.argv: # 0.5 那版在 U32 端小折角处对内只剩 0.1987（USBPAIR 要 0.2）⇒ 0.52
|
||
PITCH = float(sys.argv[sys.argv.index('--pitch') + 1])
|
||
L = lambda s: math.hypot(s[3] - s[1], s[4] - s[2]) # noqa: E731
|
||
|
||
|
||
def obstacles(board, pre, keep_up):
|
||
if '--pre-only' in sys.argv:
|
||
segs = [tuple(s[:7]) for s in pre['segs'] if keep_up or s[6] not in UP]
|
||
vias = [tuple(v[:3]) for v in pre['vias'] if keep_up or v[2] not in UP]
|
||
else:
|
||
segs = [tuple(s[:7]) for s in board['segs'] if s[0] in (1, 2) and s[6] not in UP]
|
||
vias = [tuple(v[:3]) for v in board['vias'] if v[2] not in UP]
|
||
if keep_up:
|
||
segs += [tuple(s[:7]) for s in pre['segs'] if s[6] in UP]
|
||
vias += [tuple(v[:3]) for v in pre['vias'] if v[2] in UP]
|
||
if '--free-3v3hub' in sys.argv:
|
||
# +3V3_HUB 的远程取电线（离 U32 中心 > 8 mm）在 L1 上把 J37 东侧整片围住 —— UP 先布、它最后再补
|
||
u32 = (51.5, 38.6)
|
||
far = lambda x, y: math.hypot(x - u32[0], y - u32[1]) > 8.0 # noqa: E731
|
||
segs = [s for s in segs if not (s[6] == '+3V3_HUB' and far(s[1], s[2]) and far(s[3], s[4]))]
|
||
vias = [v for v in vias if not (v[2] == '+3V3_HUB' and far(v[0], v[1]))]
|
||
return segs, vias
|
||
|
||
|
||
def route_follow(pads, segs, vias, pre, logs):
|
||
u"""默认布法：DP 先、DM 贴着（照 route_pairs 的 USBUP）。"""
|
||
def virt(net):
|
||
vs = [v for v in pre['vias'] if v[2] == net]
|
||
return [['UP', 'fan:%s%d' % (net, k), v[0], v[1], 0.3, 0.3, 1, net, 'VIA'] for k, v in enumerate(vs)]
|
||
dp, dm = R.PAIRS['USBUP']
|
||
pdp, pdm = virt(dp), virt(dm)
|
||
fence = R.u32_fence(pads)
|
||
lp = {1: [(0.0, 0.0, R.B.BW, R.B.BH)], 2: [RT.pad_rect(q, 3.0) for q in pdp + pdm]}
|
||
s, v = R.route_one(dp, pdp, R.DIFF_W, pads, segs, vias, [], logs, pen_pads=pdm, fence=fence, hug=lp)
|
||
band = {1: [], 2: []}
|
||
for q in s:
|
||
band[q[0]].append(R._seg_box(q, R.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 pdm:
|
||
r = RT.pad_rect(q, R.HUG_PAD)
|
||
for l in RT.LAY:
|
||
band[l].append(r)
|
||
s2, v2 = R.route_one(dm, pdm, R.DIFF_W, pads, segs + s, vias + v, [], logs, hug=band, fence=fence)
|
||
return list(s) + list(s2), list(v) + list(v2)
|
||
|
||
|
||
def _chain(segs, a, b):
|
||
u"""把一堆首尾相接的线段串成 a → b 的折线（点列）。"""
|
||
pts = [a]
|
||
rest = [((s[1], s[2]), (s[3], s[4])) for s in segs]
|
||
cur = a
|
||
while rest:
|
||
k = min(range(len(rest)), key=lambda i: min(math.hypot(rest[i][0][0] - cur[0], rest[i][0][1] - cur[1]),
|
||
math.hypot(rest[i][1][0] - cur[0], rest[i][1][1] - cur[1])))
|
||
p, q = rest.pop(k)
|
||
if math.hypot(q[0] - cur[0], q[1] - cur[1]) < math.hypot(p[0] - cur[0], p[1] - cur[1]):
|
||
p, q = q, p
|
||
if math.hypot(p[0] - cur[0], p[1] - cur[1]) > 0.02:
|
||
pts.append(p)
|
||
pts.append(q)
|
||
cur = q
|
||
if math.hypot(cur[0] - b[0], cur[1] - b[1]) > 0.02:
|
||
pts.append(b)
|
||
out = [pts[0]] # 去掉共线的中间点
|
||
for i in range(1, len(pts) - 1):
|
||
(x0, y0), (x1, y1), (x2, y2) = out[-1], pts[i], pts[i + 1]
|
||
if abs((x1 - x0) * (y2 - y1) - (y1 - y0) * (x2 - x1)) > 1e-6 and math.hypot(x1 - x0, y1 - y0) > 1e-6:
|
||
out.append(pts[i])
|
||
out.append(pts[-1])
|
||
return out
|
||
|
||
|
||
def _offset(pts, d):
|
||
u"""折线向左侧（行进方向左手）偏 d；拐角取两条偏移线的交点。"""
|
||
dirs = []
|
||
for (x0, y0), (x1, y1) in zip(pts, pts[1:]):
|
||
n = math.hypot(x1 - x0, y1 - y0)
|
||
dirs.append(((x1 - x0) / n, (y1 - y0) / n))
|
||
nrm = [(-dy, dx) for dx, dy in dirs]
|
||
out = [(pts[0][0] + d * nrm[0][0], pts[0][1] + d * nrm[0][1])]
|
||
for i in range(1, len(pts) - 1):
|
||
(ax, ay), (bx, by) = nrm[i - 1], nrm[i]
|
||
(ux, uy), (vx, vy) = dirs[i - 1], dirs[i]
|
||
p1 = (pts[i][0] + d * ax, pts[i][1] + d * ay)
|
||
p2 = (pts[i][0] + d * bx, pts[i][1] + d * by)
|
||
den = ux * vy - uy * vx
|
||
if abs(den) < 1e-9:
|
||
out.append(p1)
|
||
continue
|
||
t = ((p2[0] - p1[0]) * vy - (p2[1] - p1[1]) * vx) / den
|
||
out.append((p1[0] + t * ux, p1[1] + t * uy))
|
||
out.append((pts[-1][0] + d * nrm[-1][0], pts[-1][1] + d * nrm[-1][1]))
|
||
return out
|
||
|
||
|
||
def route_centerline(pads, segs, vias, pre, logs):
|
||
dp, dm = R.PAIRS['USBUP']
|
||
vdp = [v for v in pre['vias'] if v[2] == dp]
|
||
vdm = [v for v in pre['vias'] if v[2] == dm]
|
||
# 按 x 分端：U32 侧（西）/ J23 侧（东）
|
||
u_dp, j_dp = sorted(vdp, key=lambda v: v[0])
|
||
u_dm, j_dm = sorted(vdm, key=lambda v: v[0])
|
||
c0 = ((u_dp[0] + u_dm[0]) / 2, (u_dp[1] + u_dm[1]) / 2)
|
||
c1 = ((j_dp[0] + j_dm[0]) / 2, (j_dp[1] + j_dm[1]) / 2)
|
||
print(u'中心线落点 U32 侧 (%.3f, %.3f) / J23 侧 (%.3f, %.3f)' % (c0 + c1))
|
||
net = '#UP'
|
||
ps = [['UP', 'fan:c0', c0[0], c0[1], 0.3, 0.3, 1, net], ['UP', 'fan:c1', c1[0], c1[1], 0.3, 0.3, 1, net]]
|
||
w = PITCH + R.DIFF_W
|
||
|
||
def astar_l1(g, starts, goals, nn, halfw): # 照 route_base._astar_l4：只 L1、不许换层
|
||
s1 = [s for s in starts if s[0] == 1]
|
||
g1 = [q for q in goals if q[0] == 1]
|
||
vc = RT.VIA_COST
|
||
RT.VIA_COST = 1e9
|
||
try:
|
||
path = R._orig_astar(g, s1, g1, nn, halfw)
|
||
finally:
|
||
RT.VIA_COST = vc
|
||
if path and any(a[0] != 1 for a in path):
|
||
return None
|
||
return path
|
||
old = RT.astar
|
||
RT.astar = astar_l1
|
||
try:
|
||
s, v = R.route_one(net, ps, w, pads, segs, vias, [], logs, fence=list(R.u32_fence(pads)) + list(EXTRA_FENCE))
|
||
finally:
|
||
RT.astar = old
|
||
if not s or v:
|
||
logs.append(u'中心线没布通（段 %d / 孔 %d）' % (len(s), len(v)))
|
||
return [], []
|
||
pts = _chain([q for q in s if q[0] == 1], c0, c1)
|
||
left, right = _offset(pts, PITCH / 2), _offset(pts, -PITCH / 2)
|
||
d = lambda p, q: math.hypot(p[0] - q[0], p[1] - q[1]) # noqa: E731
|
||
# DP 在哪一侧：两端都要对得上，否则这对线在中间得交叉
|
||
end_ok_left = d(left[-1], j_dp) + d(right[-1], j_dm) < d(left[-1], j_dm) + d(right[-1], j_dp)
|
||
start_ok_left = d(left[0], u_dp) + d(right[0], u_dm) < d(left[0], u_dm) + d(right[0], u_dp)
|
||
if end_ok_left != start_ok_left:
|
||
logs.append(u'两端的 DP / DM 左右不一致（中心线在中间要交叉），这版不能用')
|
||
pdp, pdm = (left, right) if end_ok_left else (right, left)
|
||
out = []
|
||
for net_, pl, a, b in ((dp, pdp, u_dp, j_dp), (dm, pdm, u_dm, j_dm)):
|
||
full = [(a[0], a[1])] + pl + [(b[0], b[1])]
|
||
for p, q in zip(full, full[1:]):
|
||
if d(p, q) > 1e-4:
|
||
out.append((1, round(p[0], 4), round(p[1], 4), round(q[0], 4), round(q[1], 4), R.DIFF_W, net_))
|
||
return out, []
|
||
|
||
|
||
def check(new_s, segs, vias, pads):
|
||
u"""新铜对异网：线-线 / 线-孔 / 线-盘 最小净距；对内最小净距。"""
|
||
def pd(px, py, s):
|
||
x1, y1, x2, y2 = s[1], s[2], s[3], s[4]
|
||
dx, dy = x2 - x1, y2 - y1
|
||
L2 = dx * dx + dy * dy
|
||
t = 0 if L2 == 0 else max(0, min(1, ((px - x1) * dx + (py - y1) * dy) / L2))
|
||
return math.hypot(px - (x1 + t * dx), py - (y1 + t * dy))
|
||
|
||
def samples(s, step=0.05):
|
||
n = max(2, int(L(s) / step))
|
||
return [(s[1] + (s[3] - s[1]) * k / n, s[2] + (s[4] - s[2]) * k / n) for k in range(n + 1)]
|
||
worst, pair = (9.0, ''), 9.0
|
||
for s in new_s:
|
||
pts = samples(s)
|
||
bx0, by0, bx1, by1 = min(s[1], s[3]) - 2, min(s[2], s[4]) - 2, max(s[1], s[3]) + 2, max(s[2], s[4]) + 2
|
||
for t in segs:
|
||
if t[0] != s[0] or t[6] in UP or max(t[1], t[3]) < bx0 or min(t[1], t[3]) > bx1 or \
|
||
max(t[2], t[4]) < by0 or min(t[2], t[4]) > by1:
|
||
continue
|
||
g = min(pd(x, y, t) for x, y in pts) - s[5] / 2 - t[5] / 2
|
||
if g < worst[0]:
|
||
worst = (g, u'线-线 %s' % t[6])
|
||
for v in vias:
|
||
if v[2] in UP or not (bx0 <= v[0] <= bx1 and by0 <= v[1] <= by1):
|
||
continue
|
||
g = min(math.hypot(v[0] - x, v[1] - y) for x, y in pts) - s[5] / 2 - 0.305
|
||
if g < worst[0]:
|
||
worst = (g, u'线-孔 %s' % v[2])
|
||
for q in pads:
|
||
if q[7] in UP or q[6] not in (s[0], 12) or not (bx0 <= q[2] <= bx1 and by0 <= q[3] <= by1):
|
||
continue
|
||
g = min(math.hypot(max(q[2] - q[4] / 2 - x, x - q[2] - q[4] / 2, 0),
|
||
max(q[3] - q[5] / 2 - y, y - q[3] - q[5] / 2, 0)) for x, y in pts) - s[5] / 2
|
||
if g < worst[0]:
|
||
worst = (g, u'线-盘 %s.%s' % (q[0], q[1]))
|
||
for t in new_s:
|
||
if t[6] != s[6] and t[0] == s[0]:
|
||
pair = min(pair, min(pd(x, y, t) for x, y in pts) - s[5] / 2 - t[5] / 2)
|
||
return worst, pair
|
||
|
||
|
||
def main():
|
||
board = json.load(io.open(os.path.join(HERE, '_board_for_up.json'), encoding='utf-8'))
|
||
pre = json.load(io.open(os.path.join(HERE, '_base_preroute_0911.json'), encoding='utf-8'))
|
||
centre = '--centerline' in sys.argv
|
||
segs, vias = obstacles(board, pre, keep_up=not centre)
|
||
pads = R.load_pads()
|
||
print(u'模式 %s；障碍：线 %d / 孔 %d / 焊盘 %d；网格 %.3f' % (u'中心线' if centre else u'DP 先 DM 跟', len(segs), len(vias),
|
||
len(pads), RT.G))
|
||
logs = []
|
||
pad_pen, layer_dir = RT.PAD_PEN, RT.LAYER_DIR
|
||
RT.PAD_PEN = R.DP_PAD_PEN
|
||
RT.LAYER_DIR = {}
|
||
try:
|
||
new_s, new_v = (route_centerline if centre else route_follow)(pads, segs, vias, pre, logs)
|
||
finally:
|
||
RT.PAD_PEN, RT.LAYER_DIR = pad_pen, layer_dir
|
||
obst_s = segs + ([] if not centre else [])
|
||
worst, pair = check(new_s, obst_s, vias, pads)
|
||
all_s = segs + new_s + ([tuple(s[:7]) for s in pre['segs'] if s[6] in UP] if centre else [])
|
||
all_v = vias + new_v + ([tuple(v[:3]) for v in pre['vias'] if v[2] in UP] if centre else [])
|
||
pairs_bak = R.RB.PAIRS
|
||
R.RB.PAIRS = [p for p in pairs_bak if p[0] == 'USBUP']
|
||
try:
|
||
ret = R.dp_return_vias(pads, all_s, all_v, [], logs)
|
||
finally:
|
||
R.RB.PAIRS = pairs_bak
|
||
lens = {}
|
||
for net in UP:
|
||
ss = [q for q in all_s if q[6] == net]
|
||
vv = [q for q in all_v if q[2] == net]
|
||
lens[net] = sum(L(q) for q in ss)
|
||
print(u'%s：新增 %d 段 %.1f mm（含预布共 %.1f mm）L1 %.1f / L4 %.1f，孔共 %d'
|
||
% (net, sum(1 for q in new_s if q[6] == net), sum(L(q) for q in new_s if q[6] == net),
|
||
lens[net], sum(L(q) for q in ss if q[0] == 1), sum(L(q) for q in ss if q[0] == 2), len(vv)))
|
||
print(u'长度差 %.2f mm；新铜对异网最小净距 %.3f（%s，规则 0.15）；对内最小净距 %.3f（USBPAIR 0.2）'
|
||
% (abs(lens['UP_DP'] - lens['UP_DM']), worst[0], worst[1], pair))
|
||
print(u'GND 回流孔 %d 颗；日志 %d 条' % (len(ret), len(logs)))
|
||
for m in logs:
|
||
print(u' ' + m)
|
||
io.open(os.path.join(HERE, '_up_route.out.json'), 'w', encoding='utf-8').write(json.dumps(
|
||
{'segs': new_s, 'vias': new_v, 'ret': ret, 'logs': logs, 'grid': RT.G, 'centerline': centre,
|
||
'worst': worst, 'pair_clr': pair}, ensure_ascii=False))
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|