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:
design_constraint(DiffPairTag(), priority=2).trace_width(RUN_WIDTH)on the four nets.design_constraint(PairNeckTag(), priority=4).trace_width(neck_width)on the neckRouteobjects. 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 inlayout_qfn_escape: 0.13 mm here.design_constraint(Lane0RunTag(), Lane1RunTag(), priority=2).clearance(PAIR_TO_PAIR)between the two lanes’ runRouteobjects 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 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 theshapesmapping 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:
LandpatternFour 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:
ComponentA fictional two-lane device with fine-pitch pads. Not a real part.
- 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.
- class TwoLaneLink(lane_tags_on_nets=False)[source]#
Bases:
CircuitTwo lanes from one device to its mirror image, necked at both ends.
- Parameters:
lane_tags_on_nets (bool)
- points: list[RoutePoint]#
- class layout_diff_pair_escape_design(*args, **kwargs)[source]#
Bases:
SampleDesignThe two-lane link on the sample board.
- class layout_diff_pair_escape_failure_design(*args, **kwargs)[source]#
Bases:
SampleDesignThe same link with the pair-to-pair tags on the nets. The rule then covers the necks too, and a neck cannot be routed.