Panelize: How to reserve space for overhanging components

[markh-de]

Our board has a USB-C receptacle that hangs over the southern edge of the board so that the component touches the V-cut that separates the single board(s) from the frame.

The overhanging component in detail:

The whole panel:

The boards in this panel cannot be separated properly.

We therefore need to add some space between the southern edge of the board(s) and the frame.

Obviously, increasing the frame's vspace to, for example, 10mm ...

"framing": {
    "type": "frame",
    "vspace": "10mm",
    "width": "10mm"
},

... does the job on southern edge, but of course also on the northern edge, where it is not desired:

I think that overhanging components are relatively common, so I wonder if increasing the frame space in a dedicated direction can be done easily, maybe with some custom code?

Thank you very much in advance for any support!
Mark

[yaqwsx]

At the moment, the best solution would probably be to implement a Layout plugin that would make the frame space asymmetrical. The CLI allows only for symmetrical spacing (for the sake of simplicity).

Nevertheless, the idea of considering bound bounding box including components for panel arrangement sounds good, and it is worth implementing.

[markh-de]

Thanks for your quick answer.

However, I'm afraid I don't know where to start.

Which part would I need to override/implement, where would the code have to go and how would I refer to it from the configuration file?

I would be so grateful for example code and usage examples on how to implement such customizations via plugins, as I cannot find enough information in the docs (or are too unexperienced in Python to understand what to do).

Again, thanks for help!
Mark

[yaqwsx]

The plugins are documented in https://github.com/yaqwsx/KiKit/blob/master/doc/plugins.md, and their interface is specified in https://github.com/yaqwsx/KiKit/blob/master/kikit/plugin.py.

I made a mistake; what you want is a framing plugin. It can look something like this (it is not particularly nice as even the internals of KiKit assumes symmetrical frame spacing. So most of the plugin is copy-paste of KiKit framing implementation with added assymetry):

from kikit.plugin import FramingPlugin
from kikit.panelize import Panel, expandRect, rectToRing
from kikit.units import mm
from kikit.common import shpBoxToRect, combineBoundingBoxes
from kikit.substrate import Substrate

from shapely.geometry import Polygon, LineString, box

from typing import Tuple, Iterable


class Framing(FramingPlugin):
    def _spacing(self) -> Tuple[int, int, int, int]:
        # This could be somehow configurable, but for the sake of simplicity,
        # lets specify it as constant in the code

        # Top, right, bottom, left
        return 5 * mm, 2 * mm, 10 * mm, 2 * mm

    def buildFraming(self, panel: Panel) -> Iterable[LineString]:
        # KiKit framing allows us only to specify symmetrical spacing,
        # so we reimplement the same functionality with slight tweaks
        width = self.preset["framing"]["width"]
        TOP, RIGHT, BOTTOM, LEFT = self._spacing()

        # Lets build rectangles representing the frame:
        frameInnerRect = shpBoxToRect(panel.boardsBBox())
        # We expand the frame asymmetrically
        frameInnerRect.SetX(frameInnerRect.GetX() - LEFT)
        frameInnerRect.SetWidth(frameInnerRect.GetWidth() + LEFT + RIGHT)
        frameInnerRect.SetY(frameInnerRect.GetY() - TOP)
        frameInnerRect.SetHeight(frameInnerRect.GetHeight() + TOP + BOTTOM)

        frameOuterRect = expandRect(frameInnerRect, width)

        # Append the frame to the panel
        outerRing = rectToRing(frameOuterRect)
        innerRing = rectToRing(frameInnerRect)
        polygon = Polygon(outerRing, [innerRing])
        panel.appendSubstrate(polygon)

        # Compute frame cuts
        innerArea = panel.substrates[0].boundingBox()
        for s in panel.substrates:
            innerArea = combineBoundingBoxes(innerArea, s.boundingBox())
        frameCutsV = panel.makeFrameCutsV(innerArea, frameInnerRect, frameOuterRect)
        frameCutsH = panel.makeFrameCutsH(innerArea, frameInnerRect, frameOuterRect)
        return chain(frameCutsV, frameCutsH)

    def buildDummyFramingSubstrates(self, substrates: Iterable[Substrate]) -> Iterable[Substrate]:
        # We follow exactly what KiKit does:
        TOP, RIGHT, BOTTOM, LEFT = self._spacing()
        dummy = []
        # Find common bounding box of the panel substrates
        minx, miny, maxx, maxy = substrates[0].bounds()
        for s in substrates:
            minx2, miny2, maxx2, maxy2 = s.bounds()
            minx = min(minx, minx2)
            miny = min(miny, miny2)
            maxx = max(maxx, maxx2)
            maxy = max(maxy, maxy2)
        width = 5 * mm
        # Note that the constructed substrates has to have a non-zero width/height.
        # If the width is zero, we break the input condition of the neighbor finding
        # algorithm (as there is no distinguishion between left and right side)
        top = box(minx, miny - 2 * TOP - width, maxx, miny - 2 * TOP)
        dummy.append(self.polygonToSubstrate(top))

        bottom = box(minx, maxy + 2 * BOTTOM, maxx, maxy + 2 * BOTTOM + width)
        dummy.append(self.polygonToSubstrate(bottom))

        left = box(minx - 2 * LEFT - width, miny, minx - 2 * LEFT, maxy)
        dummy.append(self.polygonToSubstrate(left))

        right = box(maxx + 2 * RIGHT, miny, maxx + 2 * RIGHT + width, maxy)
        dummy.append(self.polygonToSubstrate(right))

        return dummy

    def polygonToSubstrate(self, polygon):
        s = Substrate([])
        s.union(polygon)
        return s

You can use it as --framing 'plugin; code: thepluginfilename.py.Framing'. You get:

[markh-de]

Jan,
First, thank you for your reply and the code example!

However, I'm not sure if framing is the right spot for the changes. Because, if you enable the V-cut layer, you will notice that the V-cut still hits the overhanging parts:

Also, in your illustration above it can be seen that the problem persists between each single board. They cannot be separated with V-cuts.

The V-cut lines (for each separate board) would have to be moved further away from the board's edge(s). Tabs would not be allowed on edges using this "overhang" feature.

Any ideas how to solve this?

Thanks again!
Mark

PS: For anyone trying Jan's above code example: You'll have to change the return statement of buildFraming() to return chain(frameCutsV, frameCutsH) (add from itertools import chain).

[yaqwsx]

Framing is the right place, as the plugin method returns cuts for the frame. The simplest solution for you is to probably not return the horizontal cuts.

But, with a 24 hour delay and fresh mind; I think you could just disable frame cuts and not bother with any plugin. Since you use V-cuts, no explicit frame cuts are necessary.