Stretch tab to another board instead of partition line

[TimVosch]

Hey, I got this working for irregular shaped boards. It's not perfect since - with my script - you still NEED framing substrate between the boards. Which i'd prefer not too since it's extra waste.

Is therer a way to have a tab stretch to another board instead of the partition line?

import pcbnew
import sys
import math
from kikit import panelize_ui_impl as ki
from kikit.panelize import Panel, Origin, Substrate
from kikit.annotations import TabAnnotation
from kikit.common import VECTOR2I
from kikit.units import mm
from shapely.geometry import LineString, GeometryCollection
from shapely.ops import unary_union
from typing import Iterable, List, Tuple, Union

# Check if the correct number of command-line arguments is provided
if len(sys.argv) < 2:
    print("Usage: python3 script.py <...input_boards>")
    sys.exit(1)

board_paths = sys.argv[1:]
project_name = "outputpanel.kicad_pcb"

framing = {
    "type": "frame",  # only rail on top and bottom
    "width": "0mm"  # Width of the rail
}
cuts = {
    "type": "mousebites"
}
tabs = {  # Add tabs between board and board as well as board and rail
    "type": "spacing",  # Place them with constant width and spacing
    "vwidth": "5mm",
    "spacing": "5mm"
}
tooling = {
    "type": "3hole",
    "hoffset": "5mm",
    "voffset": "3mm",
    "size": "3mm"
}
layout = {
    "hbackbone": "5mm",
    "vbackbone": "5mm",
}
preset = ki.obtainPreset([], layout=layout, tabs=tabs, cuts=cuts, framing=framing, tooling=tooling)

# load board
boards = [pcbnew.LoadBoard(board_path) for board_path in board_paths]

# Create a panel
panel = Panel(project_name)
panel.inheritDesignSettings(boards[0])
panel.inheritProperties(boards[0])
panel.inheritTitleBlock(boards[0])
substrateCount = len(panel.substrates)

# get outline
areas = [ki.readSourceArea(preset["source"], board) for board in boards]

for ix in range(len(board_paths)):
    panel.appendBoard(board_paths[ix],
                      destination=VECTOR2I(0, ix * 25 * mm),
                      origin=Origin.TopLeft,
                      tolerance=1 * mm,
                      inheritDrc=False,  # Required to avoid merging DRC rules
                      )
substrates = panel.substrates[substrateCount:]


def create_partitions(substrates: List[Substrate]):
    for sub in substrates:
        exterior = sub.exterior().buffer(2*mm).exterior
        sub.partitionLine = GeometryCollection(exterior)
    panel.debugRenderPartitionLines()


create_partitions(panel.substrates)

cuts = panel.buildTabsFromAnnotations(2*mm)
panel.makeMouseBites(cuts, diameter=.5*mm, spacing=1*mm)
framingPreset = preset["framing"]
panel.makeTightFrame(framingPreset["width"], framingPreset["slotwidth"],
                     framingPreset["hspace"], framingPreset["vspace"],
                     framingPreset["mintotalwidth"], framingPreset["mintotalheight"],
                     framingPreset["maxtotalwidth"], framingPreset["maxtotalheight"])
panel.boardSubstrate.removeIslands()
ki.addFilletAndChamfer(framingPreset, panel)

panel.save()

[yaqwsx]

The tab always spans from the partition line to the board edge. This is hard-coded. But you don't need to change that. The proper way is to create an irregularly shaped partition line. A partition line can be an arbitrary polyline. Once you are scripting, you can make the partition line any shape you need.

There were experiments with building the partition line using Voron diagrams. However, I never made it to cover all the edge cases I was able to find.

[TimVosch]

Thanks for the very quick response.
I've got the partitionlines correct using the buffer command on the exterior per board.

for sub in substrates:
        exterior = sub.exterior().buffer(2*mm).exterior
        sub.partitionLine = GeometryCollection(exterior)

But I am looking to create something like on the right:

Or is this simply a case of "perfectly" lining up the tab annotations?

[yaqwsx]

This solely depends on the tab placement strategy. At the moment, the default strategies only consider the rectangular partition line as it is the only partition line the CLI uses. Once you are scripting, you are free to use any tab placement strategy or you can use hand-placed annotations.

I am aware this should be part of KiKit, however, there is only a limited use for irregularly shaped boards (there are not many users wanting this features), hence, I had a limited motivation to invest a lot of effort into this.

[TimVosch]

I definitely appreciate kikit and the work you've put in! I was just wondering if I missed the functionality. I'll dive deepen into the code to see how I can generate the tabs myself.

Cheers