layout_diff_pair_escape module#

Neck two differential pairs down at a fine-pitch device with a tag on the neck routes, and key the pair-to-pair rule on the runs so it stays off the device.

Use this pattern when pairs leave a device whose pads are too close for the run width, and the run needs pair-to-pair spacing that the device pins cannot give. Two lanes leave a fictional device with pads at 0.3 mm pitch, 0.15 mm wide, in the order lane 0 p, lane 0 n, lane 1 p, lane 1 n. A 0.25 mm run trace centred on one of those pads comes within 0.1 mm of the next pad, under the 0.127 mm fab floor of the sample substrate, and the two lanes’ inner pads are 0.15 mm apart, well inside a 0.5 mm pair-to-pair spacing.

Each leg is three code routes: a neck from the device pad to a RoutePoint where the run starts, the run between the two devices’ run points, and a neck from the far run point into the far pad. Three rules apply to the copper:

  1. design_constraint(DiffPairTag(), priority=2).trace_width(RUN_WIDTH) on the four nets.

  2. design_constraint(PairNeckTag(), priority=4).trace_width(neck_width) on the neck Route objects. The higher priority wins on the necks; the runs keep the run width. The neck width is the device pad width less 0.02 mm, rounded down to 0.01 mm and checked against the pad and the fab floor, as in layout_qfn_escape: 0.13 mm here.

  3. design_constraint(Lane0RunTag(), Lane1RunTag(), priority=2).clearance(PAIR_TO_PAIR) between the two lanes’ run Route objects only. The necks carry neither run tag, so the pair-to-pair rule does not reach the device, where the pins sit closer than it allows.

The run points are placed from the same numbers: within a lane, p and n centres sit RUN_WIDTH + INTRA_PAIR_GAP (0.45 mm) apart, and the two lanes’ inner conductors sit PAIR_TO_PAIR (0.5 mm) apart edge to edge. Because the run points already sit at that spacing, the pair-to-pair rule sets nothing in this design: the 0.5 mm between the runs comes from where they are placed. The rule takes effect in the failure design below, which keeps rule 3 unchanged but assigns Lane0RunTag and Lane1RunTag to the lanes’ nets instead of their runs, so the rule covers every route of the two lanes, necks included.

Measured on jitx 4.6, building layout_diff_pair_escape_design: every neck realized 0.13 mm wide and every run 0.25 mm, the two lanes’ run copper came no closer than 0.5 mm, and the design’s issues listed routing as satisfied.

Each run goes straight between two placed RoutePoint objects, and came back as that straight line. Each neck leaves a pad that sits closer to its neighbours than the pair-to-pair rule allows, which is why the rule is keyed on the runs. layout_diff_pair_escape_failure_design puts the two lane tags on the nets instead of the runs, so the 0.5 mm rule also covers the necks, whose pads are 0.15 mm apart. Built on jitx 4.6, one or more necks came back with no copper, and the issues read Unrealizable Route: Insufficient space and Unable to find path for requested route.

The widths here are illustrative and not solved for an impedance.

The test, tests/test_layout_diff_pair_escape.py, checks the rules and the authored geometry offline. With JITX_PATTERN_RUNTIME=1 and a runtime started at the project root, it builds both designs, measures each segment’s width and the spacing between the lanes’ runs on the first, and reads the issues of both.

PAD_PITCH = 0.3#

Centre-to-centre spacing of the device’s pads, in mm.

PAD_WIDTH = 0.15#

The device pad’s short side, across the escape, in mm.

PAD_LENGTH = 0.6#

The device pad’s long side, along the escape, in mm.

RUN_WIDTH = 0.25#

Trace width in the run, in mm.

INTRA_PAIR_GAP = 0.2#

Edge-to-edge gap between p and n in the run, in mm.

PAIR_TO_PAIR = 0.5#

Edge-to-edge clearance between the two lanes in the run, in mm.

DEVICE_X = 10.0#

The devices sit at -DEVICE_X and +DEVICE_X, in mm.

FAN_RUN = 1.5#

From a device’s pad centres to where the run starts, in mm.

class DiffPairTag[source]#

Bases: Tag

Differential pair nets: routed at RUN_WIDTH.

class PairNeckTag[source]#

Bases: Tag

Neck segments between a device pad and the run.

class Lane0RunTag[source]#

Bases: Tag

Lane 0’s run segments.

class Lane1RunTag[source]#

Bases: Tag

Lane 1’s run segments.

class DevicePad(*args, **kwargs)[source]#

Bases: Pad

shape: Shape | PadShape = Polygon(elements=((0.3, 0.075), (-0.3, 0.075), (-0.3, -0.075), (0.3, -0.075)), holes=())#

The geometric shape of the pad or a PadShape to specify the regular shape and the shape when non-functional pads are removed. Can be overridden on a per-layer basis by shapes. When using a PadShape with nfp, the nfp removal does not apply to surface layers, to have surface nfp removal, use the shapes mapping to declare top and bottom explicitly.

soldermask = Soldermask(shape=Polygon(elements=((0.325, 0.1), (-0.325, 0.1), (-0.325, -0.1), (0.325, -0.1)), holes=()), side=<Side.Top: 0>)#
class DeviceLandpattern(*args, **kwargs)[source]#

Bases: Landpattern

Four pads in a column at PAD_PITCH, top to bottom.

pads = [DevicePad().at(0, 0.44999999999999996), DevicePad().at(0, 0.15), DevicePad().at(0, -0.15), DevicePad().at(0, -0.44999999999999996)]#
class FinePitchDevice[source]#

Bases: Component

A fictional two-lane device with fine-pitch pads. Not a real part.

manufacturer: str | None = 'Fictional'#

Manufacturer for this component.

mpn: str | None = 'EXAMPLE-2LANE'#

Manufacturer part number for this component.

reference_designator_prefix: str | None = 'U'#

Reference designator prefix for this component. This will be used to generate a unique reference designator for each component of the same type.

Note

This field is a required data point for matching components between builds. If this value changes (including changing from unset to set), it will be treated as a new component, even if nothing else changes.

lane0 = DiffPair()#
lane1 = DiffPair()#
landpattern = DeviceLandpattern()#
symbol = BoxSymbol()#
run_offsets()[source]#

Each conductor’s y in the run, keyed by (lane, “p” or “n”). Lane 0 is above the axis, lane 1 below, in the device’s pin order.

Return type:

dict[tuple[int, str], float]

Bases: Circuit

Two lanes from one device to its mirror image, necked at both ends.

Parameters:

lane_tags_on_nets (bool)

nets: list[Net]#
points: list[RoutePoint]#
near_necks: list[Route]#
runs: list[Route]#
far_necks: list[Route]#
class layout_diff_pair_escape_design(*args, **kwargs)[source]#

Bases: SampleDesign

The two-lane link on the sample board.

circuit: Circuit = TwoLaneLink()#
class layout_diff_pair_escape_failure_design(*args, **kwargs)[source]#

Bases: SampleDesign

The same link with the pair-to-pair tags on the nets. The rule then covers the necks too, and a neck cannot be routed.

circuit: Circuit = TwoLaneLink(lane_tags_on_nets=True)#