Is it possible to panelize different boards in to one panel?

[t123yh]

Hi, I would like to know if we can use kikit to panelize two(or more) different boards with same shape in to one panel?

[yaqwsx]

In this case, you have to use KiKit as a library and write a custom Python script for the panelization. Basically, you have operations like "Put board here", "add tabs in this way", "add frame" and save the panel. See [documentation] https://github.com/yaqwsx/KiKit/blob/master/doc/panelization.md.

The UI is designed so it is easy to use and covers 99 % of the use cases. For anything more complicated, using KiKit as a library is the intended way.

[WebDust21]

Getting extremely frustrated here due to the complete lack of examples (or usable documentation) on KiKit 1.x.x.
Several months back, I had managed to use the RB0002 script as a basis on v0.7 to cobble together 5-6 different multi-design panelization projects...

Then I made the colossal mistake of updating to 1.0.5 (complete laptop reinstall/upgrade, etc.)
All of my Python KiKit scripts are now totally and uselessly broken. And for the life of me, I cannot seem to find ANY useful/helpful documentation OR examples for how to put the puzzle pieces back together.

• KiKit 0.7 started with "panel = panelize.Panel()". And ended with "panel.save('./output.kicad_pcb')"
  That's logical enough, create a blank, then save it when you're done? Well, based on the Python errors I'm getting, it seems that 1.0.5 cleverly reverses these--nothing in the documentation mentions this change, and frankly, it doesn't make any sense, either. Moving the filename to the initializer gets rid of the errors. OK, first problem down. Next?

• The previously "recommended method" was to put lines in the Eco.1 (or Eco.2) layers on the PCB, to specify where mousebites should go.
  Guess what: that function (Panel.layerToTabs) is now completely nonexistent. I can't find anywhere in any documentation on the entire Internet what the recommended replacement for this functionality is (if any). Give up.

So let's see if it's possible to even just put 4 different PCBs into a single kicad_pcb file.

• "RuntimeError: Merging of DRC rules of multiple boards is currently unsupported"
  What now, a new functionality that's enabled by default, but is unsupported???!
  Fortunately a search of the documentation for "DRC" turned up a search result (wow, that was unprecedented). Setting "inheritDrc=False" on each "appendBoard" call seems to have solved that error. Again, nowhere is this setting mentioned in the documentation--the only reference is in the function declaration.

After all that frustration, I was finally able to get the 4 boards in a single file (all identical dimensions BTW, just very slight modifications to the parts on them)...an hour later than it would have been on 0.7.

I'll take a bunch of random stabs in the dark trying to figure out how to get the mousebites between the 4 (identically shaped and sized) PCBs--or until I get too frustrated to continue...and just give up and have to panelize the boards by hand.

Is it too much to ask for at least ONE working Python scripting example SOMEWHERE on the entire Internet???? Please???!

[yaqwsx]

Hi,
at the moment making more complete documentation is on the table also with improvement regarding scripting (e.g., #283). However, this work is extremely time-consuming and it takes a long time. Since this is a project I am not paid for, I have a tendency to prioritize my needs and bug fixes reported by my sponsors.

• If you have a set of scripts that fulfill your needs with v0.7, nothing prevents you from using it! Just install it and use it as you used to. Changing the major number of software versions means that backward compatibility was broken. That's why we shifted from 0.x.x to 1.x.x.
• the layerToTabs was replaced by the more superior concept of tabs from annotation. There is some explanation in examples, CLI documentation, and the partition line concept is explained here https://github.com/yaqwsx/KiKit/blob/master/doc/understandingTabs.md
• to place the tabs, simply put annotation (programmatically or manually in the source board) and let KiKit render them panel.buildTabsFromAnnotations.
• what I can offer at the moment is to walk through the CLI-related code. It covers pretty much everything and it shouldn't be hard to follow. Start with

  KiKit/kikit/panelize_ui.py

  Line 219 in d52b7c9

  def doPanelization(input, output, preset, plugins=[]):

I am sorry that KiKit is causing you frustration. That is not my intention. The software is provided "as is" and I am trying to improve it as much as I can.

[WebDust21]

So after another 3 hours of tweaking, guessing and throwing code snippits at the board to see what stuck, I somehow managed to get a panelized end result...

Firstly, I managed to infer from the documentation that there was a likely connection between "annotations" and the KiKit footprints. (I can't find any place where this is clearly indicated in the KiKit documentation--it's just hinted.) So I went to the KiCad PCM (Plugin and Content Manager), and installed them. Piece of cake, right?
Well, nothing happens. No new entries in the PCB footprint libraries, nor in the SCH symbol libraries. Having no idea where the files had been 'installed', I went back to the KiCad PCM, uninstalled the footprints--and noted the paths given. Then reinstalled the footprints, dug into the filesystem, found the files, and then manually added them to the KiCad footprint and symbol libraries.
NOW the footprints/symbols are useable. (Also worth noting that nowhere in the documentation does it explain what the schematic symbols are used for; my educated guess is that they're placed in the schematic so the required PCB footprints have a reference and aren't auto-deleted when the PCB-schematic link is updated.)

So now the fun begins. How in the world do I reference such 'annotations' in KiKit? Yes, this is mentioned in the CLI documentation--but if there's one thing the documentation IS clear about, it's that the ONLY way to panelize multiple PCB designs is to use the Python scripting interface. It can't be done with CLI or GUI.

An absolute lifesaver was one recent KiKit Python script I managed to find. While it's quite overcomplicated for my very simple needs...at least it was an example with code that at least purportedly worked for something for someone. https://gist.github.com/mairas/f1531ec54dd04aad01e922324e6affa6
Confoundingly bizarre is that several functions used in that script are mentioned nowhere in the entire KiKit repository (except for the source code). They don't even garner a passing mention in the documentation. Worse yet...without them, I don't see any way to get the desired output.
And even further confusing is that the one function I had to use ("dummyFramingSubstrate") is anything but a dummy function. The arguments actually are hugely important!

Ugh......

Anyway, I did finally manage to get a panelized output. But could you PLEASE at least have ONE working Python scripting example for multi-board design panelizing SOMEWHERE??!?!?!? Even if there isn't documentation for the functions, I can usually hack around with an example until I figure out what the functions/arguments do, and then adapt it to do what I need.

Regardless, I ended up with the following script:

from kikit import panelize, substrate
from kikit.units import mm, deg
from kikit import panelize_ui_impl as ki
import shapely
import pcbnew
import sys

#tabWidth = panelize.fromMm(65)
#slotWidth = panelize.fromMm(2.5)
panelOrigin = pcbnew.wxPointMM(0, 0)

panel = panelize.Panel("./output.kicad_pcb")

pos3 = panel.appendBoard("./boardA.kicad_pcb", panelOrigin + pcbnew.wxPointMM(0, -36), origin=panelize.Origin.Center, tolerance=panelize.fromMm(10), inheritDrc=False)
pos4 = panel.appendBoard("./boardB.kicad_pcb", panelOrigin + pcbnew.wxPointMM(0, -18), origin=panelize.Origin.Center, tolerance=panelize.fromMm(10), inheritDrc=False)

pos5 = panel.appendBoard("./boardC.kicad_pcb", panelOrigin + pcbnew.wxPointMM(0, 0), origin=panelize.Origin.Center, tolerance=panelize.fromMm(10), inheritDrc=False)
pos6 = panel.appendBoard("./boardD.kicad_pcb", panelOrigin + pcbnew.wxPointMM(0, 18), origin=panelize.Origin.Center, tolerance=panelize.fromMm(10), inheritDrc=False)


framing_substrates = ki.dummyFramingSubstrate(panel.substrates, (1 *mm, 1 *mm))  # NOT A DUMMY FUNCTION!  Args change width of mousebite "perforations" as well as length of "reach" for connecting mousebites
panel.buildPartitionLineFromBB(framing_substrates)

# add the tabs
cuts = panel.buildTabsFromAnnotations()


#tabs, cuts = panel.layerToTabs("Eco1.User", panelize.fromMm(5))	# tab width
#panel.appendSubstrate(cuts)
#panel.addMillFillets(panelize.fromMm(0.75))	# distance to "reach/rounding"

panel.makeMouseBites(cuts, diameter=0.5 * mm, spacing=0.75 * mm, offset=0 * mm, prolongation=0 * mm)

panel.save()

[yaqwsx]

Well, thank you for sharing your experience. I will definitely use it as feedback once I will be updating the documentation. Just a few notes to clear a few things up and possibly help you:

• the footprints installed via PCM should appear automatically in Pcbnew (usually after restart). If they don't, this is a bug in KiCAD and it is out of my control. You should probably make it reproducible and report it to the KiCAD issue tracker (https://gitlab.com/kicad/code/kicad/-/issues)
• KiKit doesn't care about schematics (it only cares about footprints), but for convenience, we provide also schematics symbols so you can easily update the board. I was hoping this is clear from the "traditional KiCAD workflow". You are right, the only place where I talk about what footprint should be used for the annotations is:
  • https://gitlab.com/kicad/code/kicad/-/issues
  • and I advise you to inspect the example board in examples where the footprints are placed
• The footprints aren't the only way of adding annotation, you can also place it programmatically (https://github.com/yaqwsx/KiKit/blob/d52b7c946fd80efbe4897f5223e1828eb6d5b92a/kikit/annotations.py)
• dummyFramingSubstrate isn't a dummy function (why would it even be there if it wouldn't be doing anything?). "Dummy" is the attribute of "framing substrates", not the function. Just like the docstring of the function says "Generate dummy substrates that pretend to be the frame (to appear)". This function is necessary to create substrates that fake to be the frame (which is not there yet) so the partition line between the board can be correctly built.

I am aware of the current limitation in the documentation. However, writing the documentation doesn't pay my bills and it is something that I do in my spare time.

If you create some documentation/improvement in the docstring, I will be more than happy to accept a PR with that. I hope to improve the documentation in the upcoming 6-10 months (I started with the tooling for building the documentation ­– I want to be able to properly render the script output and so on). If you would like to see proper documentation for KiKit CLI scripting soon, you can consider hiring me to do.

PS: There are plans for supporting of multi-design panels without programming: #327

[MG-Programmer]

Hello guys,
I also need a script to panelize a multi design board.
When I try to use your script I got an error at the line with dummyFramingSubstrate

Traceback (most recent call last):
File "C:\Program Files\JetBrains\PyCharm Community Edition 2022.1.4\plugins\python-ce\helpers\pydev\pydevd.py", line 1491, in _exec
pydev_imports.execfile(file, globals, locals) # execute the script
File "C:\Program Files\JetBrains\PyCharm Community Edition 2022.1.4\plugins\python-ce\helpers\pydev_pydev_imps_pydev_execfile.py", line 18, in execfile
exec(compile(contents+"\n", file, 'exec'), glob, loc)
File ".../panelizer.py", line 26, in
framing_substrates = ki.dummyFramingSubstrate(panel.substrates, (1 * mm, 1 * mm)) # NOT A DUMMY FUNCTION! Args change width of mousebite "perforations" as well as length of "reach" for connecting mousebites
File "C:\Program Files\KiCad\6.0\bin\Lib\site-packages\kikit\panelize_ui_impl.py", line 387, in dummyFramingSubstrate
framingPreset = preset["framing"]
TypeError: tuple indices must be integers or slices, not str

[maxanier]

I have derived the KiKit GUI panelization code to create a small script that creates a panel of two different designs with identical dimensions.
You may have to adjust it for your own needs.
https://gist.github.com/maxanier/87a9e73fbd655bf040c3cead2ff43e65
Tested with KiCAD 7 and KiKit 1.1.0

[snhobbs]

I'm putting together a CLI tool for doing multi-project panelization: https://github.com/snhobbs/kikit-multipanel.

The input is a pandas DataFrame for the board placement which is read from an xls or xlsx spreadsheet. This could easily be json, csv, etc. if desired. Write a presets file and put your board arrangement into a spreadsheet the feed it into the CLI.

I included an example, more to come.

I'd like to add an second tool that uses Guillotine Cutting or a similar rectangle packing algorithm to optimize the panel arrangement. There's a rectpack library that works well if anyone is interested in helping!

[mvirkkunen]

For a simpler way to customize the layout process, you can use a layout plugin! It avoids having to rewrite a lot of the stuff that the CLI already does for you.

I wrote this simple plugin that lets you make a grid of different types of boards. The boards are simply laid out left to right and wrapped when a certain number of columns is reached. If the board sizes are not similar the results can be a bit wonky (tabs ending in mid-air etc), but it can serve as a starting point for your own layout algorithm. To use it, save the code in a file in your working directory and then just use kikit panelize normally, specifying the plugin for --layout:

kikit panelize \
  --layout 'plugin; code: multi_grid_layout.py.Plugin; cols: 3; space: 2mm; boards: 6 * board1.kicad_pcb, 3 * board2.kicad_pcb' \
  --tabs ...etc...

multi_grid_layout.py

from kikit.common import KiPoint
from kikit.panelize import Panel, expandRect, findBoardBoundingBox, pcbnew
from kikit.plugin import LayoutPlugin
from kikit.units import mm

class Plugin(LayoutPlugin):
    def buildLayout(self, panel: Panel, mainInputFile: str, _sourceArea):
        layout = self.preset["layout"]

        cols = layout.get("cols", None)
        if not cols:
            raise RuntimeError("Specify the number of colums like this: --layout '...; cols: 3'")
        cols = int(cols)

        boards = layout.get("boards", None)
        if not boards:
            raise RuntimeError("Specify the boards and counts like this: --layout '...; boards: board_a.kicad_pcb, 3*board_b.kicad_pcb'")

        panel.sourcePaths.add(mainInputFile)

        netRenamer = lambda n, orig: self.netPattern.format(n=n, orig=orig)
        refRenamer = lambda n, orig: self.refPattern.format(n=n, orig=orig)

        col = x = y = next_y = 0
        for filename in boards.split(","):
            parts = filename.split("*", 1)
            filename = parts[-1].strip()
            count = 1 if len(parts) == 1 else int(parts[0])

            for _ in range(count):
                board = pcbnew.LoadBoard(filename)

                size = panel.appendBoard(
                    filename=filename,
                    destination=KiPoint(x, y),
                    sourceArea=expandRect(findBoardBoundingBox(board), 1 * mm),
                    netRenamer=netRenamer,
                    refRenamer=refRenamer,
                    rotationAngle=self.rotation,
                    inheritDrc=False,
                )

                col += 1
                if col == cols:
                    col = x = 0
                    y = next_y
                else:
                    x += size.GetWidth() + self.vspace
                    next_y = max(next_y, y + size.GetHeight() + self.hspace)

        return panel.substrates

[buganini]

Hi, I created a GUI tool based on KiKit
https://github.com/buganini/kikit-ui

Tested with KiCad 7.0.10 and KiKit 1.5.1
You probably need to update the python executable path at the first line of ui.py

There is an alignment tool to fill the gap between automatic and manual grid panelization.
The alignment tool can also be used exclusively on the selected subboard.
An "auto" cut method to use V-Cut method preferably and fallback to mousebites method if V-Cut is not feasible.

Tab and tight frame functions are adapted from kikit code.

Manual tab function may be added in the future.

[sirivias]

This is a great UI tool to layout multiple boards on one panel - it lets you add boards and arrange them, with all of the options that I know to look for. It also lets you save configurations as .kikit_pnl files, and run them in the cli. This also means that you can generate the panels with the cli once you have it all setup. I would love to see this put into kikit, it could be merged with the "Panelize PCB" GUI if you all were amenable. Good work here @buganini !