diff --git a/bench/diagnose.py b/bench/diagnose.py index 7c8a4d5..9464e2a 100644 --- a/bench/diagnose.py +++ b/bench/diagnose.py @@ -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 diff --git a/src/freeroute/board/search_tree.py b/src/freeroute/board/search_tree.py index db37279..4bf17e5 100644 --- a/src/freeroute/board/search_tree.py +++ b/src/freeroute/board/search_tree.py @@ -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): diff --git a/src/freeroute/geometry/__init__.py b/src/freeroute/geometry/__init__.py index cb9f673..2b259b3 100644 --- a/src/freeroute/geometry/__init__.py +++ b/src/freeroute/geometry/__init__.py @@ -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", ] diff --git a/src/freeroute/geometry/octagon.py b/src/freeroute/geometry/octagon.py index 02e97ca..fd90f48 100644 --- a/src/freeroute/geometry/octagon.py +++ b/src/freeroute/geometry/octagon.py @@ -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). diff --git a/src/freeroute/route/exact_router.py b/src/freeroute/route/exact_router.py index 38e6fe5..2b0f9b9 100644 --- a/src/freeroute/route/exact_router.py +++ b/src/freeroute/route/exact_router.py @@ -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]]] = [] diff --git a/src/freeroute/route/grid_router.py b/src/freeroute/route/grid_router.py index c4bdf00..ce5540a 100644 --- a/src/freeroute/route/grid_router.py +++ b/src/freeroute/route/grid_router.py @@ -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 --------------------------------------------------------- diff --git a/tests/route/test_axis_escapes.py b/tests/route/test_axis_escapes.py new file mode 100644 index 0000000..c9a0918 --- /dev/null +++ b/tests/route/test_axis_escapes.py @@ -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))