Let pins on turned fine-pitch pads leave along the pad's axis
A QFN placed at 45 degrees had no exit on the grid: every horizontal or vertical step from a pin passes its neighbours inside clearance. A pin whose pad is turned more than ten degrees off the grid axes now leaves along the pad's own axis, away from the part, until an L from there to a grid cell clears every other net's pad, then searches as usual. The slanted leg is checked and stored as an exact slab (segment_slab), not its bounding box, in the grid stub checks and in the exact engine. Where pins leave side by side, a cell names only its first owner, so stubs are also indexed per cell for every connection near them; the exact stub-vs-stub check, trace entry and rip-up all consult that index. A pin with an axis exit and no clear cell reports no way out instead of falling back to a cell on another net's route. diagnose.py replays with the exits.
This commit is contained in:
@@ -215,6 +215,8 @@ def diagnose(
|
||||
|
||||
# the board as the best pass left it
|
||||
state = _fresh(seen)
|
||||
# pins on turned pads leave along their pad's axis: replay with the same exits
|
||||
state._axis_exits = dict(routed._axis_exits)
|
||||
conns = state._conns
|
||||
for idx, (path, a_end, b_end) in best.items():
|
||||
conns[idx].a_end, conns[idx].b_end = a_end, b_end
|
||||
|
||||
@@ -18,7 +18,7 @@ from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from freeroute.geometry import IntBox, Simplex, overlaps_2d, segment_octagon
|
||||
from freeroute.geometry import IntBox, IntPoint, Simplex, overlaps_2d, segment_octagon, segment_slab
|
||||
|
||||
__all__ = ["TreeShape", "ShapeSearchTree"]
|
||||
|
||||
@@ -63,7 +63,9 @@ class TreeShape:
|
||||
segment swept by ``half_width + clearance`` (exact integer superset)."""
|
||||
if self.seg is None:
|
||||
return self.tile.offset(clearance)
|
||||
a, b, half_width = self.seg
|
||||
a, b, half_width = self.seg[-3:]
|
||||
if self.seg[0] == "slab": # a slanted pin exit, at any angle
|
||||
return segment_slab(a, b, half_width + clearance)
|
||||
return segment_octagon(a, b, half_width + clearance)
|
||||
|
||||
|
||||
@@ -151,6 +153,25 @@ class ShapeSearchTree:
|
||||
return True
|
||||
return False
|
||||
|
||||
def segment_conflict(
|
||||
self, a: IntPoint, b: IntPoint, half_width: int, net_no: int, layer: int,
|
||||
clearance: int, kind: str = "wire",
|
||||
) -> bool:
|
||||
""":meth:`clearance_conflict` for a slanted segment, checked on its
|
||||
exact swept copper instead of its bounding box (which would reach the
|
||||
neighbouring pads of a pin leaving along its turned pad's axis)."""
|
||||
copper = segment_slab(a, b, half_width)
|
||||
grown = segment_slab(a, b, half_width + clearance)
|
||||
for shape in self.overlapping(grown.bounding_box()):
|
||||
if shape.net_no == net_no or not shape.on_layer(layer):
|
||||
continue
|
||||
if shape.blocks != "all" and shape.blocks != kind + "s":
|
||||
continue
|
||||
other = shape.exact if shape.exact is not None else shape.tile
|
||||
if overlaps_2d(copper if not shape.clearance else grown, other):
|
||||
return True
|
||||
return False
|
||||
|
||||
def rule_area_overlap(self, box: IntBox, layer: int, kind: str = "wire") -> bool:
|
||||
"""True if ``box`` overlaps a rule area on ``layer`` that stops ``kind``."""
|
||||
for shape in self.overlapping(box):
|
||||
|
||||
@@ -21,7 +21,7 @@ from .direction import Direction, IntDirection
|
||||
from .float_point import FloatPoint
|
||||
from .limits import CRIT_DOUBLE, CRIT_INT
|
||||
from .line import Line
|
||||
from .octagon import ceil_sqrt2, overlaps_2d, segment_octagon
|
||||
from .octagon import ceil_sqrt2, overlaps_2d, segment_octagon, segment_slab
|
||||
from .point import IntPoint, Point, RationalPoint, point, rational_point
|
||||
from .polygon import Polygon
|
||||
from .polygon_shape import PolygonShape
|
||||
@@ -59,5 +59,6 @@ __all__ = [
|
||||
"shove_segment",
|
||||
"ceil_sqrt2",
|
||||
"segment_octagon",
|
||||
"segment_slab",
|
||||
"overlaps_2d",
|
||||
]
|
||||
|
||||
@@ -29,7 +29,7 @@ from .line import Line
|
||||
from .point import IntPoint
|
||||
from .simplex import Simplex
|
||||
|
||||
__all__ = ["ceil_sqrt2", "segment_octagon", "overlaps_2d"]
|
||||
__all__ = ["ceil_sqrt2", "segment_octagon", "segment_slab", "overlaps_2d"]
|
||||
|
||||
|
||||
def ceil_sqrt2(radius: int) -> int:
|
||||
@@ -82,6 +82,46 @@ def segment_octagon(a: IntPoint, b: IntPoint, radius: int) -> Simplex:
|
||||
return Simplex.get_instance(lines)
|
||||
|
||||
|
||||
def segment_slab(a: IntPoint, b: IntPoint, radius: int) -> Simplex:
|
||||
"""Convex cover of segment ``a``-``b`` swept by ``radius``, at any angle.
|
||||
|
||||
The rectangle along the segment, ``radius`` either side, with flush ends
|
||||
like :func:`polyline.segment_box`: the ends of a trace leg sit on a pad or
|
||||
on the square corner tile of the next leg, which cover them. Corners are
|
||||
rounded away from the middle and the radius gets one unit more, so the
|
||||
side bounds never under-report, and it stays tight for a slanted segment
|
||||
off the 45-degree lines (a pin leaving along its pad's axis on a part
|
||||
turned 30 degrees).
|
||||
"""
|
||||
dx, dy = b.x - a.x, b.y - a.y
|
||||
length = math.hypot(dx, dy)
|
||||
r = max(radius, 0) + 1
|
||||
if length == 0:
|
||||
return Simplex.from_corners([
|
||||
IntPoint(a.x - r, a.y - r), IntPoint(a.x + r, a.y - r),
|
||||
IntPoint(a.x + r, a.y + r), IntPoint(a.x - r, a.y + r),
|
||||
])
|
||||
ux, uy = dx / length, dy / length
|
||||
nx, ny = -uy, ux
|
||||
mx, my = (a.x + b.x) / 2, (a.y + b.y) / 2
|
||||
|
||||
def out(x: float, y: float) -> IntPoint:
|
||||
return IntPoint(math.ceil(x) if x >= mx else math.floor(x),
|
||||
math.ceil(y) if y >= my else math.floor(y))
|
||||
|
||||
corners = [
|
||||
out(a.x + nx * r, a.y + ny * r),
|
||||
out(b.x + nx * r, b.y + ny * r),
|
||||
out(b.x - nx * r, b.y - ny * r),
|
||||
out(a.x - nx * r, a.y - ny * r),
|
||||
]
|
||||
for winding in (corners, corners[::-1]):
|
||||
slab = Simplex.from_corners(winding)
|
||||
if not slab.is_empty():
|
||||
return slab
|
||||
return Simplex(())
|
||||
|
||||
|
||||
def overlaps_2d(shape_a, shape_b) -> bool:
|
||||
"""True if the two convex tiles share 2-D area (a real clearance overlap).
|
||||
|
||||
|
||||
@@ -41,6 +41,7 @@ from freeroute.geometry import (
|
||||
Simplex,
|
||||
segment_box,
|
||||
segment_octagon,
|
||||
segment_slab,
|
||||
shove_segment,
|
||||
)
|
||||
from freeroute.geometry.polyline import corner_box
|
||||
@@ -200,13 +201,18 @@ def route_board_exact(
|
||||
zip(result.connections, ends_list, strict=False), key=lambda c: c[0][0]
|
||||
):
|
||||
wire_half = net_half.get(net_no, half_width)
|
||||
boxes = _copper_boxes(wires, vias, wire_half, via_layers, via_half)
|
||||
wire_count = len(_copper_boxes(wires, [], wire_half, via_layers, via_half))
|
||||
pieces = _copper_pieces(wires, vias, wire_half, via_layers, via_half)
|
||||
boxes = [(box, box_layers) for box, box_layers, _ in pieces]
|
||||
wire_count = len(_copper_pieces(wires, [], wire_half, via_layers, via_half))
|
||||
if any(
|
||||
tree.clearance_conflict(
|
||||
box, net_no, layer, clearance, "wire" if i < wire_count else "via"
|
||||
(
|
||||
tree.segment_conflict(*seg, wire_half, net_no, layer, clearance)
|
||||
if seg is not None
|
||||
else tree.clearance_conflict(
|
||||
box, net_no, layer, clearance, "wire" if i < wire_count else "via"
|
||||
)
|
||||
)
|
||||
for i, (box, box_layers) in enumerate(boxes)
|
||||
for i, (box, box_layers, seg) in enumerate(pieces)
|
||||
for layer in box_layers
|
||||
) or _end_in_rule_area(tree, wires, wire_half) or (
|
||||
outline is not None and not _inside_outline(
|
||||
@@ -225,9 +231,15 @@ def route_board_exact(
|
||||
v for v in dict.fromkeys(vias)
|
||||
if v not in acc.vias and not _on_fixed_via(net_no, v, fixed_vias, via_half)
|
||||
)
|
||||
for box, box_layers in boxes:
|
||||
for box, box_layers, seg in pieces:
|
||||
oid = next(owner)
|
||||
tree.insert(TreeShape(oid, net_no, box_layers, box, routed=True))
|
||||
if seg is None:
|
||||
tree.insert(TreeShape(oid, net_no, box_layers, box, routed=True))
|
||||
else: # a slanted pin exit: its exact copper, rebuilt for the DRC check
|
||||
tree.insert(TreeShape(
|
||||
oid, net_no, box_layers, box, routed=True,
|
||||
exact=segment_slab(*seg, wire_half), seg=("slab", *seg, wire_half),
|
||||
))
|
||||
acc.owners.append(oid)
|
||||
|
||||
accepted_before_recovery = set(accepted)
|
||||
@@ -662,6 +674,27 @@ def _on_fixed_via(net_no, point, fixed_vias, via_half) -> bool:
|
||||
)
|
||||
|
||||
|
||||
def _copper_pieces(wires, vias, half_width, via_layers, via_half=None):
|
||||
"""Like :func:`_copper_boxes`, but a slanted wire segment (a pin leaving
|
||||
along a turned pad's axis) comes with its end points, so it can be checked
|
||||
on its exact copper: ``(box, layers, (a, b) or None)``."""
|
||||
via_half = via_half or half_width
|
||||
pieces: list[tuple[IntBox, frozenset[int], tuple | None]] = []
|
||||
for layer, points in wires:
|
||||
on = frozenset({layer})
|
||||
for a, b in zip(points, points[1:], strict=False):
|
||||
if a.x == b.x or a.y == b.y:
|
||||
pieces.append((segment_box(a, b, half_width), on, None))
|
||||
else:
|
||||
pieces.append((segment_slab(a, b, half_width).bounding_box(), on, (a, b)))
|
||||
for c in points[1:-1]:
|
||||
pieces.append((corner_box(c, half_width), on, None))
|
||||
for loc in vias:
|
||||
vbox = IntBox(loc.x - via_half, loc.y - via_half, loc.x + via_half, loc.y + via_half)
|
||||
pieces.append((vbox, via_layers, None))
|
||||
return pieces
|
||||
|
||||
|
||||
def _copper_boxes(wires, vias, half_width, via_layers, via_half=None):
|
||||
via_half = via_half or half_width
|
||||
boxes: list[tuple[IntBox, frozenset[int]]] = []
|
||||
|
||||
@@ -34,8 +34,8 @@ import random
|
||||
from freeroute.board.board import BasicBoard
|
||||
from freeroute.board.items import ConductionArea, ObstacleArea, Pin, Via
|
||||
from freeroute.geometry import IntBox, IntPoint, Simplex
|
||||
from freeroute.geometry.octagon import overlaps_2d
|
||||
from freeroute.geometry.polyline import corner_box
|
||||
from freeroute.geometry.octagon import overlaps_2d, segment_slab
|
||||
from freeroute.geometry.polyline import corner_box, segment_box
|
||||
|
||||
__all__ = ["GridRouter", "RouteResult", "route_board"]
|
||||
|
||||
@@ -126,6 +126,7 @@ class _Connection:
|
||||
"narrow",
|
||||
"half",
|
||||
"stubs",
|
||||
"stub_near",
|
||||
)
|
||||
|
||||
def __init__(self, index: int, net_no: int, a: Pin, b: Pin) -> None:
|
||||
@@ -143,6 +144,8 @@ class _Connection:
|
||||
self.halo_nodes: list[Node] = []
|
||||
# each end's stub: its layer, its copper tiles, and the nodes it claims
|
||||
self.stubs: list[tuple[int, list[IntBox], set[Node]]] = []
|
||||
# every node its stubs come near, claimed or not (see GridRouter._stub_near)
|
||||
self.stub_near: list[Node] = []
|
||||
# the pins and zones each end may use, and which pin the route ended
|
||||
# on (None when it ended on a zone)
|
||||
self.a_group: tuple[list[Pin], list] = ([a], [])
|
||||
@@ -218,6 +221,12 @@ class GridRouter:
|
||||
self._escape_cells = 12
|
||||
self._crowded_cache: dict = {}
|
||||
self._trapped_cache: dict = {}
|
||||
# pin location -> where a pin on a turned fine-pitch pad leaves its
|
||||
# pin row along the pad's axis (None: it leaves like any other pin)
|
||||
self._axis_exits: dict[IntPoint, IntPoint | None] = {}
|
||||
# and the other nets' pads near each such pin, its stubs' obstacles
|
||||
self._axis_pads: dict[IntPoint, list] = {}
|
||||
self._part_centres: dict[int, tuple[float, float] | None] = {}
|
||||
self.heuristic_weight = max(float(heuristic_weight), 1.0)
|
||||
self.trace_width = max(trace_width, 1)
|
||||
self.clearance = max(clearance, 0)
|
||||
@@ -309,6 +318,12 @@ class GridRouter:
|
||||
self._zone_cells: dict[int, list[Node]] = {}
|
||||
# per-connection occupancy (owner = connection index)
|
||||
self._cell_owner: dict[Node, int] = {}
|
||||
# Node -> connections whose stub comes near it. A cell has one owner,
|
||||
# and a stub claims only cells nobody owns yet, so where several pins
|
||||
# leave side by side (a QFN turned 45 degrees: neighbours 0.35 mm apart
|
||||
# on each axis) the cell two stubs share names only the first, and the
|
||||
# exact check between the later stubs would never run.
|
||||
self._stub_near: dict[Node, set[int]] = {}
|
||||
# every connection whose via covers a cell, in claim order: a via two
|
||||
# connections share still blocks after the first of them is ripped,
|
||||
# and a route through it must rip all of them
|
||||
@@ -536,6 +551,13 @@ class GridRouter:
|
||||
if conns[i].net_no != net_no:
|
||||
blocking = i
|
||||
break
|
||||
if blocking is None:
|
||||
# another net's pin stub comes too close, though the cell it once
|
||||
# claimed may since have been freed by a rip of its first owner
|
||||
for i in self._stub_near.get(node, ()):
|
||||
if conns[i].net_no != net_no:
|
||||
blocking = i
|
||||
break
|
||||
if blocking is None:
|
||||
return 0.0
|
||||
if not allow_ripup:
|
||||
@@ -857,30 +879,143 @@ class GridRouter:
|
||||
clearance of the pad next door, though the straight exit clears it.
|
||||
"""
|
||||
end = self._cell_center(cell)
|
||||
dx, dy = end.x - pin_location.x, end.y - pin_location.y
|
||||
head = [pin_location]
|
||||
start = pin_location
|
||||
exit_point = self._axis_exits.get(pin_location)
|
||||
if exit_point is not None:
|
||||
# a pin on a turned fine-pitch pad first leaves along the pad's
|
||||
# axis, past the pin row, then takes the usual L to its cell
|
||||
head = [pin_location, exit_point]
|
||||
start = exit_point
|
||||
dx, dy = end.x - start.x, end.y - start.y
|
||||
if not self._orthogonal or dx == 0 or dy == 0:
|
||||
return [pin_location, end]
|
||||
if abs(dx) >= abs(dy):
|
||||
return [pin_location, IntPoint(end.x, pin_location.y), end]
|
||||
return [pin_location, IntPoint(pin_location.x, end.y), end]
|
||||
tail = [end]
|
||||
elif abs(dx) >= abs(dy):
|
||||
tail = [IntPoint(end.x, start.y), end]
|
||||
else:
|
||||
tail = [IntPoint(start.x, end.y), end]
|
||||
points = []
|
||||
for point in head + tail:
|
||||
if not points or points[-1] != point:
|
||||
points.append(point)
|
||||
return points if len(points) > 1 else [pin_location, end]
|
||||
|
||||
def _leg_shapes(self, points: list[IntPoint], half: int, grow: int = 0) -> list:
|
||||
"""A stub's copper, grown by ``grow``: a box per straight leg and per
|
||||
inner corner, and an exact slab for a slanted leg (a pad-axis exit),
|
||||
whose bounding box would reach the neighbouring pads."""
|
||||
shapes: list = []
|
||||
for a, b in zip(points, points[1:], strict=False):
|
||||
if a == b:
|
||||
continue
|
||||
if a.x == b.x or a.y == b.y:
|
||||
box = segment_box(a, b, half)
|
||||
shapes.append(box.offset(grow) if grow else box)
|
||||
else:
|
||||
shapes.append(segment_slab(a, b, half + grow))
|
||||
for c in points[1:-1]:
|
||||
box = corner_box(c, half)
|
||||
shapes.append(box.offset(grow) if grow else box)
|
||||
return shapes
|
||||
|
||||
def _axis_exit(self, pin: Pin) -> IntPoint | None:
|
||||
"""Where a pin on a turned fine-pitch pad clears its pin row.
|
||||
|
||||
A QFN placed at 45 degrees has no straight exit on the grid: every
|
||||
horizontal or vertical step from a pin passes its neighbours closer
|
||||
than the clearance. The way out is along the pad's own axis, away
|
||||
from the part, until an L from there to a grid cell clears every
|
||||
other net's pad (checked on exact shapes, as the exact engine will).
|
||||
Any angle off the grid axes counts, not just 45 degrees.
|
||||
"""
|
||||
loc = pin.location
|
||||
if loc in self._axis_exits:
|
||||
return self._axis_exits[loc]
|
||||
self._axis_exits[loc] = None
|
||||
shape = pin.shape
|
||||
if not isinstance(shape, Simplex) or shape.is_int_box():
|
||||
return None
|
||||
corners = [shape.corner_approx(i) for i in range(shape.border_line_count())]
|
||||
edges = [(b.x - a.x, b.y - a.y) for a, b in zip(corners, corners[1:] + corners[:1], strict=False)]
|
||||
lengths = [math.hypot(dx, dy) for dx, dy in edges]
|
||||
if len(edges) < 3 or max(lengths) < 1.25 * min(lengths):
|
||||
return None # no long axis to leave along
|
||||
dx, dy = edges[lengths.index(max(lengths))]
|
||||
ux, uy = dx / max(lengths), dy / max(lengths)
|
||||
if min(abs(ux), abs(uy)) < 0.17:
|
||||
return None # within ten degrees of a grid axis: the usual exits work
|
||||
centre = self._part_centre(pin)
|
||||
if centre is None:
|
||||
return None
|
||||
if (loc.x - centre[0]) * ux + (loc.y - centre[1]) * uy < 0:
|
||||
ux, uy = -ux, -uy
|
||||
reach = max((c.x - loc.x) * ux + (c.y - loc.y) * uy for c in corners)
|
||||
h, cl = self.half_width, self.clearance
|
||||
span = reach + h + cl + 16 * self.step
|
||||
others = [
|
||||
p.shape for p in self.board.get_pins()
|
||||
if p.shape is not None and p is not pin and not set(p.net_nos) & set(pin.net_nos)
|
||||
and set(p.layers) & set(pin.layers)
|
||||
and abs(p.location.x - loc.x) < 2 * span and abs(p.location.y - loc.y) < 2 * span
|
||||
]
|
||||
self._axis_pads[loc] = others
|
||||
for j in range(16):
|
||||
d = reach + h + cl + j * self.step / 2
|
||||
exit_point = IntPoint(round(loc.x + ux * d), round(loc.y + uy * d))
|
||||
out = segment_slab(loc, exit_point, h + cl)
|
||||
if any(overlaps_2d(out, o) for o in others):
|
||||
continue
|
||||
ex, ey = self._cell_of(exit_point)
|
||||
self._axis_exits[loc] = exit_point
|
||||
for ddx, ddy in itertools.product((0, -1, 1), repeat=2):
|
||||
cell = (ex + ddx, ey + ddy)
|
||||
if not (0 <= cell[0] < self.cols and 0 <= cell[1] < self.rows):
|
||||
continue
|
||||
legs = self._leg_shapes(self._stub_points(loc, cell)[1:], h, cl)
|
||||
if not any(overlaps_2d(g, o) for g in legs for o in others):
|
||||
return exit_point
|
||||
self._axis_exits[loc] = None
|
||||
return None
|
||||
|
||||
def _exit_clips_a_pad(self, pin: Pin, cell: Cell) -> bool:
|
||||
"""Whether the stub from an axis exit to ``cell`` comes closer than the
|
||||
clearance to another net's pad (exactly, as the exact engine checks):
|
||||
the exit was chosen with one clear cell, not every cell around it."""
|
||||
legs = self._leg_shapes(
|
||||
self._stub_points(pin.location, cell)[1:], self._cur_half, self.clearance
|
||||
)
|
||||
return any(overlaps_2d(g, pad) for g in legs for pad in self._axis_pads.get(pin.location, ()))
|
||||
|
||||
def _part_centre(self, pin: Pin) -> tuple[float, float] | None:
|
||||
key = pin.component_no
|
||||
if key not in self._part_centres:
|
||||
mates = [p.location for p in self.board.get_pins() if p.component_no == key] if key else []
|
||||
self._part_centres[key] = (
|
||||
(sum(m.x for m in mates) / len(mates), sum(m.y for m in mates) / len(mates))
|
||||
if len(mates) > 2 else None
|
||||
)
|
||||
return self._part_centres[key]
|
||||
|
||||
def _stub_cells(self, pin_location: IntPoint, cell: Cell, half: int | None = None) -> list[Cell]:
|
||||
"""Cells where another net's trace would come too close to the stub."""
|
||||
from freeroute.board.outline import _point_segment
|
||||
|
||||
points = self._stub_points(pin_location, cell)
|
||||
end = points[-1]
|
||||
reach = (half or self._cur_half) + self.half_width + self.clearance
|
||||
box = IntBox(
|
||||
min(pin_location.x, end.x), min(pin_location.y, end.y),
|
||||
max(pin_location.x, end.x), max(pin_location.y, end.y),
|
||||
min(p.x for p in points), min(p.y for p in points),
|
||||
max(p.x for p in points), max(p.y for p in points),
|
||||
)
|
||||
legs = list(zip(points, points[1:], strict=False))
|
||||
return [
|
||||
c
|
||||
for c in self._cells_in_box(box, reach)
|
||||
if min(_point_segment(self._cell_center(c), a, b) for a, b in legs) < reach
|
||||
]
|
||||
joints = points[1:] # each carries a square corner tile
|
||||
|
||||
def near(c) -> bool:
|
||||
p = self._cell_center(c)
|
||||
if min(_point_segment(p, a, b) for a, b in legs) < reach:
|
||||
return True
|
||||
return any(max(abs(p.x - j.x), abs(p.y - j.y)) < reach for j in joints)
|
||||
|
||||
return [c for c in self._cells_in_box(box, reach) if near(c)]
|
||||
|
||||
def _stub_clear(
|
||||
self,
|
||||
@@ -896,13 +1031,12 @@ class GridRouter:
|
||||
if keepouts:
|
||||
# the stub is off the grid, so check it exactly, as the exact
|
||||
# engine will: its copper grown by clearance must miss every keepout
|
||||
from freeroute.geometry.polyline import Polyline, PolylineShape
|
||||
|
||||
points = self._stub_points(pin.location, cell)
|
||||
if points[-1] != pin.location:
|
||||
for tile in PolylineShape(Polyline(points), self._cur_half).tiles():
|
||||
grown = tile.offset(self.clearance)
|
||||
if any(k.overlaps(grown if needs else tile) for k, needs in keepouts):
|
||||
legs = self._leg_shapes(points, self._cur_half)
|
||||
grown_legs = self._leg_shapes(points, self._cur_half, self.clearance)
|
||||
for tile, grown in zip(legs, grown_legs, strict=True):
|
||||
if any(overlaps_2d(k, grown if needs else tile) for k, needs in keepouts):
|
||||
return False
|
||||
# the track's round end at the pin, for a rule area
|
||||
cap = corner_box(pin.location, self._cur_half)
|
||||
@@ -916,15 +1050,16 @@ class GridRouter:
|
||||
allow_ripup and all(conns[i].rip_count < self.rip_cap for i in owners)
|
||||
)
|
||||
|
||||
def _stub_tiles(self, pin_location: IntPoint, cell: Cell, half: int) -> list[IntBox]:
|
||||
"""The stub's copper: its legs, and a square at each corner and at the
|
||||
cell end, where the route carries on."""
|
||||
def _stub_tiles(self, pin_location: IntPoint, cell: Cell, half: int, grow: int = 0) -> list:
|
||||
"""The stub's copper (grown by ``grow``): its legs, and a square at each
|
||||
corner and at the cell end, where the route carries on."""
|
||||
points = self._stub_points(pin_location, cell)
|
||||
tiles = [corner_box(point, half) for point in points[1:]]
|
||||
tiles: list = [
|
||||
corner_box(point, half).offset(grow) if grow else corner_box(point, half)
|
||||
for point in points[1:]
|
||||
]
|
||||
if len(points) > 1 and points[-1] != pin_location:
|
||||
from freeroute.geometry.polyline import Polyline, PolylineShape
|
||||
|
||||
tiles += PolylineShape(Polyline(points), half).tiles()
|
||||
tiles += self._leg_shapes(points, half, grow)
|
||||
return tiles
|
||||
|
||||
def _stub_owners(
|
||||
@@ -944,13 +1079,23 @@ class GridRouter:
|
||||
other = [tiles for lay, tiles, nodes in conns[owner].stubs if node in nodes]
|
||||
if other:
|
||||
if grown is None:
|
||||
grown = [
|
||||
t.offset(self.clearance)
|
||||
for t in self._stub_tiles(pin.location, cell, half or self._cur_half)
|
||||
]
|
||||
if not any(g.overlaps(t) for tiles in other for t in tiles for g in grown):
|
||||
grown = self._stub_tiles(
|
||||
pin.location, cell, half or self._cur_half, self.clearance
|
||||
)
|
||||
if not any(overlaps_2d(g, t) for tiles in other for t in tiles for g in grown):
|
||||
continue
|
||||
owners.add(owner)
|
||||
for idx in self._stub_near.get(node, ()):
|
||||
if idx in owners or conns[idx].net_no == net_no:
|
||||
continue
|
||||
theirs = [tiles for lay, tiles, _ in conns[idx].stubs if lay == layer]
|
||||
if theirs:
|
||||
if grown is None:
|
||||
grown = self._stub_tiles(
|
||||
pin.location, cell, half or self._cur_half, self.clearance
|
||||
)
|
||||
if any(overlaps_2d(g, t) for tiles in theirs for t in tiles for g in grown):
|
||||
owners.add(idx)
|
||||
owners.update(self._via_others(c, net_no, conns))
|
||||
return owners
|
||||
|
||||
@@ -1031,11 +1176,16 @@ class GridRouter:
|
||||
return self._cell_of(IntPoint((box.ll.x + box.ur.x) // 2, (box.ll.y + box.ur.y) // 2))
|
||||
|
||||
def _stub_cost(self, pin: Pin, node: Node) -> float:
|
||||
c = self._cell_center(node[:2])
|
||||
dx, dy = abs(c.x - pin.location.x), abs(c.y - pin.location.y)
|
||||
if self._orthogonal: # measured the way the route itself is allowed to move
|
||||
return (dx + dy) / self.step
|
||||
return math.hypot(dx, dy) / self.step
|
||||
if self._axis_exits.get(pin.location) is None:
|
||||
c = self._cell_center(node[:2])
|
||||
dx, dy = abs(c.x - pin.location.x), abs(c.y - pin.location.y)
|
||||
if self._orthogonal: # measured the way the route itself is allowed to move
|
||||
return (dx + dy) / self.step
|
||||
return math.hypot(dx, dy) / self.step
|
||||
points = self._stub_points(pin.location, node[:2])
|
||||
return sum(
|
||||
math.hypot(b.x - a.x, b.y - a.y) for a, b in zip(points, points[1:], strict=False)
|
||||
) / self.step
|
||||
|
||||
def _end_nodes(self, pin: Pin, net_no: int, conns, allow_ripup: bool = False) -> set[Node]:
|
||||
"""Nodes a route may start or end on for ``pin``: the nearest cell and
|
||||
@@ -1045,14 +1195,21 @@ class GridRouter:
|
||||
everywhere else, or a pin whose only way out another net has taken
|
||||
could never have it back."""
|
||||
layers = [layer for layer in pin.layers if layer in self.layers]
|
||||
cx, cy = self._cell_of(pin.location)
|
||||
exit_point = None
|
||||
if self._orthogonal and self._crowded(pin, net_no):
|
||||
exit_point = self._axis_exit(pin)
|
||||
cx, cy = self._cell_of(exit_point if exit_point is not None else pin.location)
|
||||
nodes: set[Node] = set()
|
||||
for dx, dy in ((0, 0), *self._neighbours):
|
||||
cell = (cx + dx, cy + dy)
|
||||
if not (0 <= cell[0] < self.cols and 0 <= cell[1] < self.rows):
|
||||
continue
|
||||
if exit_point is not None and self._exit_clips_a_pad(pin, cell):
|
||||
continue
|
||||
for layer in layers:
|
||||
if (dx or dy) and self._enter_cost(cell, layer, net_no, allow_ripup, conns) is None:
|
||||
# the pin's own cell is in its pad; an exit cell is not
|
||||
checked = dx or dy or exit_point is not None
|
||||
if checked and self._enter_cost(cell, layer, net_no, allow_ripup, conns) is None:
|
||||
continue
|
||||
if self._stub_clear(pin, cell, layer, net_no, conns, allow_ripup=allow_ripup):
|
||||
nodes.add((*cell, layer))
|
||||
@@ -1062,6 +1219,11 @@ class GridRouter:
|
||||
# cost, so it is only taken where a short step would not do.
|
||||
if self._orthogonal and self._crowded(pin, net_no) and self._trapped(pin, net_no, nodes):
|
||||
nodes |= self._escape_nodes(pin, net_no, conns, layers, (cx, cy), allow_ripup)
|
||||
if not nodes and exit_point is not None:
|
||||
# every cell past the pin row is taken: report no way out, so the
|
||||
# search goes on to rip-up, rather than fall back to a cell out in
|
||||
# the open on top of another net's route
|
||||
return nodes
|
||||
if not nodes: # nothing clear: fall back to the nearest cell, as before
|
||||
nodes = {(cx, cy, layer) for layer in layers}
|
||||
if self._keepout_boxes and not any(
|
||||
@@ -1135,7 +1297,6 @@ class GridRouter:
|
||||
whose stub from the pin clears every other net's pad by the full
|
||||
clearance, checked on the stub's copper tiles as the exact engine
|
||||
will rather than on the grid."""
|
||||
from freeroute.geometry.polyline import Polyline, PolylineShape
|
||||
|
||||
reach = self._escape_cells
|
||||
near = [
|
||||
@@ -1157,17 +1318,14 @@ class GridRouter:
|
||||
cell = (cx + dx * k + sx, cy + dy * k + sy)
|
||||
if not (0 <= cell[0] < self.cols and 0 <= cell[1] < self.rows):
|
||||
break
|
||||
grown = [
|
||||
tile.offset(self.clearance)
|
||||
for tile in PolylineShape(
|
||||
Polyline(self._stub_points(pin.location, cell)), self._cur_half
|
||||
).tiles()
|
||||
]
|
||||
grown = self._leg_shapes(
|
||||
self._stub_points(pin.location, cell), self._cur_half, self.clearance
|
||||
)
|
||||
for layer in layers:
|
||||
if self._enter_cost(cell, layer, net_no, allow_ripup, conns) is None:
|
||||
continue
|
||||
if any(
|
||||
layer in box_layers and any(g.overlaps(box) for g in grown)
|
||||
layer in box_layers and any(overlaps_2d(g, box) for g in grown)
|
||||
for box, box_layers in near
|
||||
):
|
||||
continue
|
||||
@@ -1230,6 +1388,7 @@ class GridRouter:
|
||||
conn.via_halo.append(c)
|
||||
ends = ((conn.a_end, wire_segs[0], 0), (conn.b_end, wire_segs[-1], -1)) if wire_segs else ()
|
||||
conn.stubs = []
|
||||
self._forget_stubs(conn)
|
||||
for pin, (layer, cells), at in ends:
|
||||
if not isinstance(pin, Pin):
|
||||
continue # ended on a zone or a plane: no stub
|
||||
@@ -1237,6 +1396,8 @@ class GridRouter:
|
||||
claimed: set[Node] = set()
|
||||
for c in self._stub_cells(pin.location, cell, half):
|
||||
node = (*c, layer)
|
||||
self._stub_near.setdefault(node, set()).add(conn.index)
|
||||
conn.stub_near.append(node)
|
||||
if node not in self._cell_owner:
|
||||
self._cell_owner[node] = conn.index
|
||||
conn.trace_cells.append((c, layer))
|
||||
@@ -1272,6 +1433,15 @@ class GridRouter:
|
||||
conn.routed = True
|
||||
self._settle(conn, -1)
|
||||
|
||||
def _forget_stubs(self, conn: _Connection) -> None:
|
||||
for node in conn.stub_near:
|
||||
near = self._stub_near.get(node)
|
||||
if near is not None:
|
||||
near.discard(conn.index)
|
||||
if not near:
|
||||
del self._stub_near[node]
|
||||
conn.stub_near = []
|
||||
|
||||
def _rip(self, conn: _Connection) -> None:
|
||||
for cell, layer in conn.trace_cells:
|
||||
if self._cell_owner.get((*cell, layer)) == conn.index:
|
||||
@@ -1292,6 +1462,7 @@ class GridRouter:
|
||||
conn.halo_nodes = []
|
||||
conn.trace_cells = []
|
||||
conn.stubs = []
|
||||
self._forget_stubs(conn)
|
||||
for cell in conn.via_cells:
|
||||
count = self._via_nets.get(cell)
|
||||
if count and count.get(conn.net_no):
|
||||
@@ -1328,6 +1499,9 @@ class GridRouter:
|
||||
for i in self._halo.get((cx, cy, cl), ()):
|
||||
if conns[i].net_no != net_no:
|
||||
owners.add(i)
|
||||
for i in self._stub_near.get((cx, cy, cl), ()):
|
||||
if conns[i].net_no != net_no:
|
||||
owners.add(i)
|
||||
return owners
|
||||
|
||||
# --- pin access ---------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
"""Pins of a fine-pitch part turned off the grid axes leave along their pads.
|
||||
|
||||
A QFN at 45 degrees has no straight exit: every horizontal or vertical step
|
||||
from a pin passes its neighbours closer than the clearance (0.35 mm away on
|
||||
each axis at 0.5 mm pitch). The grid leaves along the pad's own axis first,
|
||||
past the pin row, and the exact engine checks that slanted leg on its exact
|
||||
copper. Found on th-eda's lift ESC, where a QFN-24 at 45 degrees left 15
|
||||
connections unroutable on an empty board.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
|
||||
import pytest
|
||||
|
||||
from freeroute.board import build_board
|
||||
from freeroute.dsn import parse_dsn
|
||||
from freeroute.geometry import IntPoint, overlaps_2d, segment_slab
|
||||
from freeroute.route.grid_router import GridRouter
|
||||
from freeroute.route.pipeline import (
|
||||
_rule_clearance_dsn,
|
||||
_rule_width_dsn,
|
||||
_via_half_board,
|
||||
build_exact_routing_result,
|
||||
)
|
||||
|
||||
|
||||
def _qfn_side_dsn(rotation: float) -> str:
|
||||
"""Two rows of five 0.25 x 0.8 mm pads at 0.5 mm pitch (one side of a
|
||||
QFN and its opposite side), turned by ``rotation``; each pin of the top
|
||||
row is its own net, routed to a pad 4.5 mm out, the pads fanned 1.5 mm
|
||||
apart."""
|
||||
cx, cy = 100000, -100000
|
||||
t = math.radians(rotation)
|
||||
out = (-math.sin(t), math.cos(t)) # the pads' outward axis after turning
|
||||
along = (math.cos(t), math.sin(t)) # the pin row
|
||||
pins, targets, nets = [], [], []
|
||||
for i in range(5):
|
||||
x = -1000 + 500 * i
|
||||
pins += [f"(pin P {i + 1} {x} 1000)", f"(pin P {i + 6} {x} -1000)"]
|
||||
px = cx + x * math.cos(t) - 1000 * math.sin(t)
|
||||
py = cy + x * math.sin(t) + 1000 * math.cos(t)
|
||||
spread = 1500 * (i - 2) - x # fan the far pads out to 1.5 mm apart
|
||||
tx = px + 4500 * out[0] + spread * along[0]
|
||||
ty = py + 4500 * out[1] + spread * along[1]
|
||||
targets.append(f"(place T{i + 1} {round(tx)} {round(ty)} front 0)")
|
||||
nets.append(f"(net N{i} (pins U1-{i + 1} T{i + 1}-1))")
|
||||
return f"""(pcb qfn (parser) (resolution um 10) (unit um)
|
||||
(structure
|
||||
(layer F.Cu (type signal)) (layer B.Cu (type signal))
|
||||
(boundary (path pcb 0 115000 -115000 85000 -115000 85000 -85000 115000 -85000
|
||||
115000 -115000))
|
||||
(via "Via[0-1]_450:200_um")
|
||||
(rule (width 150) (clearance 150)))
|
||||
(placement
|
||||
(component Q (place U1 {cx} {cy} front {rotation}))
|
||||
(component T {" ".join(targets)}))
|
||||
(library
|
||||
(image Q {" ".join(pins)})
|
||||
(image T (pin t 1 0 0))
|
||||
(padstack P (shape (rect F.Cu -125 -400 125 400)) (attach off))
|
||||
(padstack t (shape (rect F.Cu -300 -300 300 300)) (attach off))
|
||||
(padstack "Via[0-1]_450:200_um" (shape (circle F.Cu 450)) (shape (circle B.Cu 450))
|
||||
(attach off)))
|
||||
(network {" ".join(nets)}))"""
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rotation", [45, 30, -45])
|
||||
def test_a_turned_fine_pitch_part_gets_its_pins_out(rotation):
|
||||
result = build_exact_routing_result(parse_dsn(_qfn_side_dsn(rotation)), resolution=2, shove=True)
|
||||
assert result.unrouted == []
|
||||
|
||||
|
||||
def test_the_exit_runs_along_the_pad_axis_and_clears_the_neighbours():
|
||||
dsn = parse_dsn(_qfn_side_dsn(45))
|
||||
s = dsn.resolution.value
|
||||
board = build_board(dsn)
|
||||
router = GridRouter(
|
||||
board,
|
||||
trace_width=round(_rule_width_dsn(dsn) * s),
|
||||
clearance=round(_rule_clearance_dsn(dsn) * s),
|
||||
via_half=_via_half_board(dsn, s),
|
||||
orthogonal=True,
|
||||
)
|
||||
pins = {p.name: p for p in board.get_pins() if p.component_ref == "U1"}
|
||||
pin = pins["3"]
|
||||
exit_point = router._axis_exit(pin)
|
||||
assert exit_point is not None
|
||||
dx, dy = exit_point.x - pin.location.x, exit_point.y - pin.location.y
|
||||
assert abs(abs(dx) - abs(dy)) <= 2 # along the 45-degree axis
|
||||
leg = segment_slab(pin.location, exit_point, router.half_width + router.clearance)
|
||||
for name in ("2", "4"):
|
||||
assert not overlaps_2d(leg, pins[name].shape)
|
||||
|
||||
|
||||
def test_a_pad_on_the_grid_axes_keeps_the_usual_exits():
|
||||
dsn = parse_dsn(_qfn_side_dsn(0))
|
||||
s = dsn.resolution.value
|
||||
board = build_board(dsn)
|
||||
router = GridRouter(board, trace_width=round(_rule_width_dsn(dsn) * s),
|
||||
clearance=round(_rule_clearance_dsn(dsn) * s), via_half=_via_half_board(dsn, s))
|
||||
pin = next(p for p in board.get_pins() if p.component_ref == "U1" and p.name == "3")
|
||||
assert router._axis_exit(pin) is None
|
||||
|
||||
|
||||
def test_a_slanted_slab_is_tight_where_a_bounding_box_is_not():
|
||||
slab = segment_slab(IntPoint(0, 0), IntPoint(10000, 10000), 750)
|
||||
# a point beside the diagonal but inside its bounding box
|
||||
from freeroute.geometry import IntBox
|
||||
|
||||
assert not overlaps_2d(slab, IntBox(8000, 0, 8100, 100))
|
||||
assert overlaps_2d(slab, IntBox(4900, 4900, 5100, 5100))
|
||||
Reference in New Issue
Block a user