landpattern module

Landpattern and Pad definitions

This module provides classes for defining component landpatterns, pads, and mappings between ports and pads.

class Landpattern

Bases: Positionable

Component landpattern definition, also known as a footprint, package, or land-pattern.

Defines the pads and associated geometry for the interface between an electrical component and the circuit board.

>>> class ZigZagLandpattern(Landpattern):
...     pad1 = MyPad().at(-0.5, 0)
...     pad2 = MyPad().at(0.5, 0)
...
...     silkscreen = Silkscreen(
...         Polyline(
...             0.1,
...             [
...                 (-0.4, 1), (-0.3, 1.2), (-0.2, 0.8),
...                 (-0.1, 1.2), (0, 0.8), (0.1, 1.2),
...                 (0.2, 0.8), (0.3, 1.2), (0.4, 1),
...             ]
...         )
...     )
...
...     courtyard = Courtyard(rectangle(2, 1))

class PadShape(shape, *, nfp=None)

Shapes of various features of a pad.

Parameters:

• shape (Shape)

• nfp (Shape | None)

shape: Shape

The geometric shape of the pad.

nfp: Shape | None = None

The geometric shape of the pad when non-functional pads are removed. When provided, it overrides the pad shape except on the top layer, bottom layer and intermediate copper layers that have traces or pours connected to the pad.

class Pad

Bases: Positionable

Class representing a pad, user code should overload this class in order to create new pad definitions. If the pad contains a Cutout it will be interpreted as a through-hole pad, otherwise it will be interpreted as a surface mount pad.

>>> class MyPad(Pad):
...     shape = Circle(diameter=0.8)
...     shapes = {
...         (0, 2): Circle(diameter=0.7),
...         1: PadShape(Circle(diameter=0.8), nfp=Circle(diameter=0.4)),
...         -1: rectangle(2., 2.),
...     }
...
...     def __init__(self):
...         self.cutout = Cutout(Circle(diameter=0.4)
...         self.soldermask = Soldermask(self.shape)

shape: Shape | PadShape

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.

shapes: dict[int | tuple[int, ...], Shape | PadShape] = {}

The geometric shapes of the pad for specific layers. Overrides shape for the given layers.

class PadMapping(entries)

Bases: Structural, Ref

Mapping between component ports and landpattern pads.

If no pad mapping is provided, a default mapping will be created that maps ports to pads in declaration order. If a port needs to be mapped to multiple pads, a PadMapping is required.

>>> class MyComponent(Component):
...     GND = Power()
...     VIN = Power()
...     VOUT = Power()
...
...     lp = MyLandpattern()
...     mappings = PadMapping({
...         GND: [lp.p[1], lp.p[4]],
...         VIN: lp.p[3],
...         VOUT: lp.p[3],
...     })

>>> class MyComponent(Component):
...     GND = Power()
...     VIN = Power()
...     VOUT = Power()
...
...     lp = MyLandpattern()
...     mappings = PadMapping({
...         GND: lp.p[1],
...         VIN: lp.p[2],
...         VOUT: lp.p[3],
...     })

Parameters:

entries (Mapping[Port, Pad | Sequence[Pad]] | Iterable[tuple[Port, Pad | Sequence[Pad]]])

get(port, default=None, /)

Return the pad or port associated with the given port or pad.

Return type:

Union[Pad, Sequence[Pad], Port, TypeVar(T)]

Parameters:

• port (Port | Pad)

• default (T)

items()

values()

inverse()

Return the inverse mapping from pads to ports.

Return type:

Mapping[Pad, Port]