KiKit is a Python library, KiCAD plugin and a CLI tool to automate several tasks in a standard KiCAD workflow like:
Then definitely consider:
Your support will allow me to allocate time to properly maintain my projects like this.
PS: Be sure to check out my other KiCAD & PCB related projects:
Everything KiKit does, can also be done via Pcbnew in KiCAD. However, you have to do it manually. One of the common scenarios is the creation of panels. Most of the tutorials on the internet guide you to use the \"append board\" functionality of Pcbnew. However, this approach is labour-intensive, error-prone and whenever, you change the board, you have to do it again.
With KiKit you just call a CLI command if you have a simple layout (e.g., a grid) or write few Python instructions like \"place board here\", \"add bridge here\", \"separate boards via mouse bites/v-cuts\" and you are done. The process is repeatable and actually much simpler than hand-drawing the panels. KiKit also allows you to easily export all the Gerbers in a single step.
You can then write a Makefile and simply call make to get all your manufacturing data and board presentation pages.
Read the CLI documentation and the panelize documentation. Also don't miss the examples. There is also a quick not on how to use panelization action plugin. If you are interested in generating solder paste stencils, see Stencil documentation
"},{"location":"#acknowledgements","title":"Acknowledgements","text":"The project is supported by:
Please, first check FAQ. If you have not found answer for your problem there, feel free to open an issue on GitHub.
If you would like to have a feature in KiKit that is currently not on a roadmap, or if you need to prepare custom panelization script (e.g., multi-design panels, panels with specific arrangement), you can consider hiring me to do the job. Just reach out to me via e-mail and we can discuss further details.
"},{"location":"acknowledgements/","title":"Acknowledgements","text":"The project is supported by:
Thank you all!
"},{"location":"cli/","title":"KiKit CLI interface","text":"KiKit offers a simple CLI interface to perform common tasks easily. You can obtain help of the interface by calling kikit --help.
The interface is structured into nested commands. On the top level, there are the following commands available:
kikit export gerber <boardFile> [<outputDir>] - export gerber files of boardFile to outputDir. If no dir is specified, a new one <boardFile>-gerbers is created.kikit export dxf <boardFile> [<outputDir>] - export board outline and paste layers to DXF. The main use case for this command is making 3D printed solder paste stencils.Read more in a separate documentation section or see a walkthrough.
"},{"location":"cli/#separate-commands","title":"Separate commands","text":"Read more in a separate documentation section.
"},{"location":"cli/#stencil-commands","title":"Stencil commands","text":"Read more in a separate documentation section.
"},{"location":"cli/#present-commands","title":"Present commands","text":"kikit present boardpage --name <pagename> -d <descriptionFile> -b <name comment boadfile> -r <resource> --template <template> --repository <url> <outputdir> - generate single webpage providing board preview and a possibility to download board files (gerbers and sources). See an example of such page.-r or --resource. Resources are files which will be copied to the output directory. Useful for images referred from description-b or --boarddefault). See template documentation for more information about templates.kikit modify references --show/--hide --pattern <pattern> <board> hide or show all references on the board matching a regular pattern.
kikit modify values --show/--hide --pattern <pattern> <board> is the same as above, just with footprint values.
KiKit respects the KiCAD component selection criteria. When you specify an input rectangle, only the components that fully fit inside the input rectangle are selected. This however take in account both name and value labels.
When you do not specify the source are explicitly, KiKit takes the board outline bounding box as the source area. Therefore, by default, components outside the board substrate are not copied to panel.
Since version 1.1 this behavior, however, changes for footprints. KiKit decides whether to keep a footprint or not based on whether its origin fits inside the source area or not. For graphical items, the behavior remains the same. The reason for this change is that often footprints reach out beyond the board edge (e.g., connectors) and the users don't want to remove them. On the other hand, graphical items (e.g., texts or arrows towards the board) are purely for documentation purposes and thus, they shouldn't be included in the panelized design.
Note that this is intended behavior; for once it is consistent with KiCAD behavior of user selection and also it allows to easily ignore surrounding comments and drawings in the board sheet (it makes no sense to have 12 same copies of the notes around the board).
How to include the components? - specify the source area explicitly to include all your components - specify tolerance: 20mm for source (i.e., --source 'tolerance: 20mm') to enlarge the board outline bounding box. The default value is 1 mm.
KiKit's millradius parameter from the postprocess section simulates the board outline milling by a tool with given radius. That means that it will round all inner corners. It is not a command to round just your tabs. That means if you specify a tool which diameter is larger than your slot, KiKit will remove the slot as such slot cannot be created with the tool.
This is an intended behavior. The options is designed for you to check if your board can be manufactured with all the features you have in your board outline. There aren't many fabrication houses that support sharp inner corners as they cannot be milled but have to be e.g., broached, which is much more complicated and expensive setup.
If you want to preserve your narrow internal slots: - don't specify millradius at all in the postprocess - specify smaller millradius but make sure that your fabrication house supports such small tools.
KiKit's mouse bites offset specifies how much should be the mouse bites put inside the board. The recommended value is 0.25 mm (read about it in this blog post). Why is it so? When you break the tab, there will be rough edges. By putting the mouse bites inside the board, these rough edges won't be sticking outside the designed board outline. When you want to fit your board in a tight enclosure, you don't have to perform manual deburing. Since it is considered a good practice, KiKit makes this the positive direction so you don't have to put minus everywhere.
If you don't want to put mouse bites inside your board, just specify zero or negative offset.
"},{"location":"faq/#i-have-board-with-no-spacing-but-some-v-cuts-are-missing","title":"I have board with no spacing, but some V-cuts are missing.","text":"The default style of tabs (spacing) does not generate in such a case any tabs, and, therefore, not cuts. Please use tab style full.
ModuleNotFoundError: No module named 'pcbnew'","text":"You probably installed KiKit via Windows command prompt, not KiCAD Command Prompt.
"},{"location":"faq/#i-would-like-to-make-a-panel-out-of-different-designs-but-there-is-no-such-option-in-help","title":"I would like to make a panel out of different designs, but there is no such option in help","text":"KiKit supports such feature. But it is not available from CLI. You have to write a simple Python script describing the panel and use KiKit as a library. Also, please refer to the panelization documentation.
If you wonder why is it in such way: there are infinitely many ways to panel your design. A single CLI/UI will not fit them all and also even for the simple cases, it would be enormous and painful to use. Much better idea is to use a language to specify the panel. But why reinvent the wheel and design a custom language when we can use Python? It integrates well with other tools and many people already know it.
"},{"location":"faq/#there-are-no-plugins-in-kicad","title":"There are no plugins in KiCAD!","text":"You have to install them via KiCAD PCM. See the installation guide.
"},{"location":"faq/#how-do-i-run-kikit-with-kicad-nightly","title":"How do I run KiKit with KiCAD nightly?","text":"See section \"Choosing KiCAD version\" in the installation guide. However, at the moment KiKit is incompatible with KiCAD 6.99.
"},{"location":"multiboard/","title":"Multiboard workflow","text":""},{"location":"multiboard/#multi-board-workflow-with-kikit","title":"Multi-board workflow with KiKit","text":"KiCAD does not support multiple board per project, nor boards with shared schematics. However, with the following workflow, you can easily draw multiple boards with shared schematics and, e.g., easily ensure that tha board connectors match.
The workflow is the following:
First, draw a separate schematics sheet for each of your boards and propagate the pins on the inter-board connectors. E.g., in one of my project it looks like this:
I also place the corresponding connectors next to each other to illustrate that they connect. Then draw your board schematics as usual - with one exception. Do not use global power symbols nor global labels, use only local labels. This ensures that the power lines are separate for each board and DRC won't complain, that you have not connected the power between two board.
Then, draw all your boards into a single board file side-by-side. See file resources/multiboard.kicad_pcb for a dead simple illustration. You can also draw lines that will help you align your boards' connectors.
Before manufacturing, use KiKit to extract the boards into a separate board files via the extract command.
This can be done in two ways:
We will show how to use it on resources/multiboard.kicad_pcb which looks like this:
"},{"location":"multiboard/#bounding-box-selection","title":"Bounding box selection","text":"Simply specify the top left and bottom right corner. Everything that fits fully inside it, will be included in the board. The command for separation of board A into a separate board file is:
kikit separate --source 'rectangle; tlx: 89mm; tly: 89mm; brx: 111mm; bry: 111mm' \\\n multiboard.kicad_pcb board_a.kicad_pcb\nAfter that, board_a.kicad_pcb will contain only a board A. Note that the \\ is there for shell as we split our command into two lines.
As you can see, the source file contains an annotation in the form of virtual footprints kikit:Board. You can place them into your document so that the arrow points to the board edge. Than you can use the reference of the annotation symbol for separation of the board. To separate board A simply invoke:
kikit separate --source 'annotation; ref: B1' \\\n multiboard.kicad_pcb board_a.kicad_pcb\nAfter that, board_a.kicad_pcb will contain only a board A. Note that the \\ is there for shell as we split our command into two lines.
Note that if panelize your boards, you don't have to separate your boards first; just use the --source with the panelization command.
When you use the separate command, KiKit preserves all annotations within the source bounding box. If you would like to strip the annotations, you can specify --stripAnnotation and KiKit will remove all annotations from the resulting board.
Present is a collection of functions providing various ways to present KiCAD boards. The main one is a simple page generator which can be used in continuous integration to build pages where your users and collagues can download the automatically generated panels.
"},{"location":"present/#requirements","title":"Requirements","text":"In order to include PCB drawings in presentations you will need to install PcbDraw.
"},{"location":"present/#template-namepath-resolution","title":"Template name/path resolution","text":"The template argument is either a name of a built-it template or a path to a directory with a user-defined template. During the name resolution the first test is for the user-defined template; i.e., check if the name provided by the user is a directory path and the directory contains the file template.json. If not, try to resolve the name as the name of the built-in template.
A template is a directory containing template files. There is a single mandatory file common to all template types template.json. An example of such file follows:
{\n \"type\": \"HtmlTemplate\",\n \"resources\": [\"css/*.css\"]\n}\nThe key type specifies what kind of template it is. Currently, only HtmlTemplate is supported (see more info about them below). Then there is the list of resources which are glob patterns for resource files which are copied to the output directory when rendering the template.
Expects an index.html file in the root of the template. This is Handlerbars template which receives the following dictionary on render:
\"repo\": self.repository,\n\"gitRev\": gitRev,\n\"gitRevShort\": gitRev[:7] if gitRev else None,\n\"datetime\": self.currentDateTime(),\n\"name\": self.name,\n\"boards\": self.boards,\n\"description\": self.description\nboards is a list of a dictionary with following keys:
front path to render of the front sideback path to render of the back sidegerbers path to archive with gerbersfile path to kicad_pcb fileSee the default template in kikit/resources/present/templates/default for a starting point for custom templates.
If you populate your boards using a reflow oven, you often need solder paste stencils. One of the inconveniences with stencils is that you have to align them manually. It is not hard, but it takes some time and a little bit of practice & tricks (e.g. to use other PCBs for stencil alignment).
KiKit provides two ways to generate stencils:
KiKit allows you to ignore components from the stencil by specifying --ignore followed by a comma separated list of components' references to exclude. Pads of these components will not appear in the stencil. This is useful, when you do not want to populate all components.
The second common option is --cutout followed by a comma separated lists of components' references. For these components, the stencil will contain a cutout based on the component courtyard. This is useful when you have already pre-populated board and you want to populate more components -- e.g., when your assembly house does not have a special IC and you populate it yourself and also, when you do a board repair.
I wrote a blog post about the 3D printed self-registering stencils on my blog. These stencils are quick solution when you urgently need a stencil but probably they don't last long and might come with imperfections.
To generate such stencil, just call:
kikit stencil createprinted [parameters] <boardFile> <outputDirectory>\n--pcbthickness FLOAT PCB thickness in mm\n--thickness FLOAT Stencil thickness in mm. Defines amount of paste\n dispensed\n--framewidth FLOAT Register frame width\n--ignore TEXT Comma separated list of components references to\n exclude from the stencil\n--frameclearance FLOAT Clearance for the stencil register in milimeters\n--enlargeholes FLOAT Enlarge pad holes by x mm\nKiKit will output two STL files representing bottom and top register to the specified directory. You can directly print these files. In theory, if you don't have small pads spacing, you could print them even on FDM machine, but I haven't tested it.
"},{"location":"stencil/#steel-stencils","title":"Steel Stencils","text":"Many fabhouses offer you to create a custom stencil. However, it is pain to align them. Therefore, KiKit offers a functionality to automatically generate stencils which fit a simple 3D printed or lasercut alignment jig.
You can find Fusion 360 model of the alignment jig here: https://a360.co/3iiFXKp. It it designed to be cut from 3mm thick acrylic. You need 4 2mm pins, 8 M2 screws and that's it. The frame can be customized - there two parameters of the model, frameWidth and frameHeight which define the largest PCB it can accept. I usually use 100x100mm and 60x60mm.
Then you issue the following command within KiKit:
kikit stencil create --jigsize 60 60 <boardFile> <outputDir>\nkikit stencil create --help. KiKit will produce 2 STL files for aligning the PCB and a zip file with gerbers for the manufacturer. When you order your stencil, let them make both top and bottom side on the same stencil. One tip for JLC PCB: set custom size of the stencil when you order it - then it fits into your package with your PCB and you don't have to pay for extra shipping.
The stencil you receive should look like on the following picture. It has mouse bites so you can easily break it off to precise size. It also has mounting holes.
Once you break the stencils off, you mount them in the jig frame:
Then you print alignment parts for your board and mount in onto the jig using M2 screws:
Then you just use 2mm pins to align the frame and you can apply the paste!
The acrylic jig is reusable - you just have to mount new alignment pieces and change the stencil.
"},{"location":"fabrication/intro/","title":"Fabrication","text":"KiKit offers fully automatic export of all data required for fabrication of your designs. Since every fabrication house has different requirements on the design files (e.g., special names of gerber files, different requirements for assembly files) there is no \"universal exporter\" in KiKit. Instead, KiKit offers special command for each supported fabrication house.
"},{"location":"fabrication/intro/#common-options","title":"Common Options","text":"All fab subcommands has a common invocation structure:
kikit fab <fabhouse> <options> <sourceDir> <outputDir>\nAll commands also support the following options:
--drc\\--no-drc (default --drc). Check for DRC violations before exporting the files. With this options, you won't send a board that fails DRC to your manufacturer.--nametemplate <str>: If you want to name your files differently, specify this option. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically. Variables in text are also supported eg: {boardTitle}_rev{boardRevision}_{date}_{}. The project variables are available with the user- prefix; e.g., `MFR: {user-mfr}```Each of the fab command also take additional, manufacturer specific, options. See documentation for the individual manufacturer below:
"},{"location":"fabrication/intro/#currently-supported","title":"Currently Supported:","text":"Note: click on the name of the manufacturer to see corresponding documentation:
To add a new fabrication command you have to extend KiKit's source code. A rather basic knowledge of python is required to do so.
Create a new file kikit/fab/fabhousename.py and implement a new command with the same name as the file. Then add the command to kikit/fab/__init__.py. The common functionality for all fabrication houses should be located in kikit/fab/common.py. You can use kikit/fab/jlcpcb.py for inspiration.
Once you implement a support for new fabrication house, open a pull request on KiKit's GitHub page.
"},{"location":"fabrication/jlcpcb/","title":"Fabrication: JLC PCB","text":"The basic usage of this exporter is:
kikit fab jlcpcb [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file gerbers.zip in OUTPUTDIR. This file can be directly uploaded to JLC PCB site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically.
If you would also like to use the SMD assembly service, you have to specify --assembly option and also provide the board --schematic <schematics_file>. KiKit will generate two extra files: bom.csv (bill of materials) and pos.csv (component placement). Use these two files when ordering the PCB assembly.
The files above will include all components on the board. You can override the default field name with option --field. This option accepts a comma separated list of names. The first found field is used. This can be used, e.g., for configuration of the board via resistors. You can put field \"LCSC\" for all components, then add fields \"CFG1_LCSC\" and \"CFG2_LCSC\" for some components. Then invoke KiKit with option --field CFG1_LCSC,LCSC for configuration 1 or --field CFG2_LCSC,LCSC for configuration 2.
You can exclude some of the components by specifying --ignore <comma separated list of references>. You can also specify component field with name JLCPCB_IGNORE (the value of the field does not matter) to exclude the component from assembly. Also, if a component misses the order code field, KiKit will show warning. When you pass option --missingError, KiKit will fail when there is a component with missing order code. This might be useful in case when you run KiKit in CI and you want to fail the build.
Note that when you order SMD assembly for a panel, you should specify panelized board and the original schematics of a single board.
"},{"location":"fabrication/jlcpcb/#correction-of-the-footprint-position","title":"Correction of the Footprint Position","text":"It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by JLCPCB_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
If your board features solder jumpers you can use the corrections to specify their default value. The solder jumper should be designed such it can fit a zero Ohm resistor in suitable size. Then specify an order code of the zero Ohm resistor for the jumper and adjust correction so it fits the default position.
Note that you can specify multiple correction fields by --corrections <comma separated list of correction filed names>. The first found correction field is used. This allows you to keep several configuration of the solder jumpers in your design e.g., in fields JLCPCB_CORRECTION_CFG_1 and JLCPCB_CORRECTION_CFG_2. Then you can simply change the board configuration by calling kikit with --corrections JLCPCB_CORRECTION_CFG_1,JLCPCB_CORRECTION or --corrections JLCPCB_CORRECTION_CFG_2,JLCPCB_CORRECTION.
The basic usage of this exporter is:
kikit fab neodenyy1 [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file top_pos.csv and bottom_pos.csv in OUTPUTDIR. This file can be used in Neoden YY1. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically.
For Neoden YY1 you must specify --assembly option and provide the board --schematic <schematics_file>. KiKit will generate files: top_pos.csv (top layer component placement) and bottom_pos.csv (bottom layer component placement). Use these two files to assembly PCB on machine.
On Neoden YY1, the position origin must use the bottom left corner of the board edge.
"},{"location":"fabrication/neodenyy1/#correction-of-the-footprint-position","title":"Correction of the Footprint Position","text":"It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by YY1_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
The basic usage of this exporter is:
kikit fab openpn [OPTIONS] BOARD OUTPUTDIR\nThis exporter creates a single file components.pos that mimics KiCAD native .pos output. However, unlike KiCAD, it adds a unique identifier to component references to ensure they are unique (in the case of panels).
The basic usage of this exporter is:
kikit fab oshpark [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find gerbers.zip in OUTPUTDIR. This file can be directly uploaded to the OSH Park site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. The extension is appended automatically.
The basic usage of this exporter is:
kikit fab pcbway [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file gerbers.zip in OUTPUTDIR. This file can be directly uploaded to the PCBWay site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. For detailed description of this option, see JLC PCB documentation.
If you would also like to use the SMD assembly service, you have to specify --assembly option and also provide the board --schematic <schematics_file>. KiKit will generate two extra files: bom.csv (bill of materials) and pos.csv (component placement). Use these two files when ordering the PCB assembly.
The files above will include all components on the board by default, except footprints having the attribute virtual set. You should provide the \"Manufacturer\" and \"PartNumber\" Fields for each component, where PartNumber refers to the manufacturers part number (and can safely contain non-digit characters). If the \"Description\" field is present, this value will be inserted in the \"Value/Description\" column in the BOM, otherwise the value of the component. It is recommended to provide no description for capacitors, resistors, and inductors, so that the value is inserted into the BOM for them. PCBWay also requires the soldering type (SMD, thru-hole, ...) to be specified. Any footprint only having SMD pads will be considered as \"SMD\", everything else as \"thru-hole\". You can manually overwrite the type by adding a \"Type\" field to the component. For the footprint column of the BOM the KiCad footprint name is used by default. Add a \"FootprintPCBWay\" field to overwrite this in the BOM list for a more human readable footprint name, if you want. Finally, notes or assembly instructions can be added using the \"Notes\" field.
You can exclude some of the components by specifying --ignore <comma separated list of references>. When you pass option --missingError, KiKit will fail when there is a component with missing manufacturer and/or part number. This might be useful in case when you run KiKit in CI and you want to fail the build.
Note that when you order assembly for a panel, you should specify panelized board and the original schematics of a single board. Use the --nBoards parameter to specify the number of boards in the panel. The quantity column is generated by multiplying this number with the number of references in each row.
It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by PCBWAY_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
If your board features solder jumpers you can use the corrections to specify their default value. The solder jumper should be designed such it can fit a zero Ohm resistor in suitable size. Then specify an order code of the zero Ohm resistor for the jumper and adjust correction so it fits the default position.
Note that you can specify multiple correction fields by --corrections <comma separated list of correction filed names>. The first found correction field is used. This allows you to keep several configuration of the solder jumpers in your design e.g., in fields PCBWAY_CORRECTION_CFG_1 and PCBWAY_CORRECTION_CFG_2. Then you can simply change the board configuration by calling kikit with --corrections PCBWAY_CORRECTION_CFG_1,PCBWAY_CORRECTION or --corrections PCBWAY_CORRECTION_CFG_2,PCBWAY_CORRECTION.
When you have multiple versions of KiCAD installed, it might be desirable to run KiKit with one or another (e.g., to not convert your designs into new format).
KiKit loads the Python API directly via a module, so which module is loaded (which KiCAD version is used) follows standard Python conventions. Therefore, to choose a particular KiCAD version, just specify the environmental variable PYTHONPATH. The path have to point to a folder containing the module (pcbnew.py file).
The most common on linux are:
stable: /usr/lib/python3/dist-packages/pcbn\nnightly: /usr/lib/kicad-nightly/lib/python3/dist-packages/\nE.g., to run KiKit with nightly, run:
PYTHONPATH=/usr/lib/kicad-nightly/lib/python3/dist-packages/ kikit\nTo run KiKit with a KiCAD you compiled (and not installed):
PYTHONPATH=path-to-sources/build/pcbnew kikit\nThis also works when you invoke make as environmental variables are propagated:
PYTHONPATH=/usr/lib/kicad-nightly/lib/python3/dist-packages/ make\nThis method is applicable to Windows, Linux and MacOS. It provides access to all of the CLI commands in a known-working container, but doesn't allow your local install of KiCad to access KiKit via the KiKit plugin.
First, install Docker. The installation procedure varies by the platform, so Google up a recent guide for your platform.
With Docker you can skip all of the install steps and instead run KiKit via (on Linux or Mac):
docker run -v $(pwd):/kikit yaqwsx/kikit --help\n--help with whatever command you want to run. Try --version or panelize) or on Windows:
docker run -v %cd%:/kikit yaqwsx/kikit --help\nNote that on Windows you might have to explicitly allow for mounting directories outside your user account (see the following topic).
"},{"location":"installation/docker/#creating-an-alias-to-kikit-in-docker-to-save-some-typing","title":"Creating an alias to KiKit in Docker to save some typing","text":"If you're on Linux or Mac and are going to run commands repeatedly within the same directory you can create an alias within the current terminal session via:
alias kikit=\"docker run -v $(pwd):/kikit yaqwsx/kikit\"\nalias is a Linux/ Unix command so won't work on Windows, you'll need to call docker run -v %cd%:/kikit yaqwsx/kikit each time. Also note that you must update the alias (by running the same alias command again) if you move to a different directory. The current working directory for the alias is \"frozen\" at the directory you create the alias in. From then on, until you close that terminal, you'll be able to just run kikit followed by the relevant paramenters (e.g. kikit --version or kikit panelize).
If you would like to run a particular version of KiKit, simply append a tag to the image name (e.g., yaqwsx/kikit:nightly), and Docker will pull that version down and run that for you instead:
docker run -v $(pwd):/kikit yaqwsx/kikit:nightly --version\nWe provide the following containers:
A full list is available on Dockerhub.
"},{"location":"installation/docker/#mac-m1-containers","title":"Mac M1 containers","text":"There are also nightly containers of Mac M1 available with tag nightly-m1.
If you want to use Makefile for your projects, the preferable way is to invoke make inside the container. The Docker image contains several often used tools and you can even run KiCAD from it (if you supply it with X-server). To call make within the container, override the container's entrypoint:
docker run -it -v $(pwd):/kikit --entrypoint '/usr/bin/make' --help\n--help with your make command, such as build or test)."},{"location":"installation/gui_and_libs/","title":"GUI and libs installation","text":""},{"location":"installation/gui_and_libs/#kikit-symbol-and-footprint-libraries","title":"KiKit Symbol and Footprint Libraries","text":"From v6 onwards KiCad comes with a \"Plugin and Content Manager\" (PCM) which can be used to add the KiKit symbol and footprint libraries used in multi-board workflows. The PCM is new functionality for KiCad though, and only does part of the installation in v6. To install the libraries using the PCM:
Tools menu and select Plugin and Content ManagerLibraries tab and scroll down to KiKit LibraryInstall and then Apply ChangesThe following steps are only required in KiCad 6, they are automated in KiCad 7:
Preferences menu and select Manage Symbol LibrariesGlobal Libraries tab, and click the + icon towards the bottom of the window then enter kikit (all lowercase) as the nickname, and ${KICAD6_3RD_PARTY}/symbols/com_github_yaqwsx_kikit-library/kikit.kicad_sym as the Library Path.OKPreferences menu and select Manage Footprint LibrariesGlobal Libraries tab, with a nickname kikit (all lowercase again), and this time enter ${KICAD6_3RD_PARTY}/footprints/com_github_yaqwsx_kikit-library/kikit.pretty for the Library Path.OKkikit alongside all the others.KiKit consists of three parts:
Unfortunately, it is not possible to install all three parts automatically in a single step due to technical limitations of KiCAD's PCM at the moment, so you have to install them separately.
"},{"location":"installation/intro/#backend-installation","title":"Backend installation","text":"The backend installation differs slightly based on the platform:
GUI plugins and libraries are available via KiCAD PCM. See details about their installation.
"},{"location":"installation/intro/#optional-dependencies","title":"Optional dependencies","text":"Some KiKit features rely on external dependencies:
We also distribute a Docker container for running KiKit in CI or on platform where it is hard to meet all dependencies. This mode doesn't support GUI. Learn more about the docker images.
"},{"location":"installation/linux/","title":"Installation on Linux","text":"KiKit is distributed as PyPi package.
"},{"location":"installation/linux/#instalation-for-kicad-installed-via-system-package-manager","title":"Instalation for KiCAD installed via system package manager","text":"The installation consists of a single command you have to enter into the terminal. If you installed KiCAD via package manager (apt, yum, etc.) you can use a regular terminal and enter pip3 install kikit. Now you are ready to use KiKit.
However, if you installed KiCAD via Flatpak, you have to open a special terminal as Flatpak sandboxes the applications. Open terminal and invoke flatpak run --command=sh org.kicad.KiCad, this will open a terminal session inside the KiCAD\u2019s sandbox. Now you can install pip via python3 -m ensurepip and then, inside the same terminal you can install KiKit: python3 -m pip install kikit. If you would like to use CLI interface, all commands have to be invoked inside the shell flatpak run --command=sh org.kicad.KiCad, and, instead of kikit something you have to use python -m kikit.ui something.
Now you can test that it works:
> kikit --help\nYou should get something like this:
Usage: kikit [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nNow you are done with the basic installation. If you plan to use graphical interface, install GUI frontend and libraries via PCM.
"},{"location":"installation/macos/","title":"KiKit Installation on MacOS","text":"Installation on MacOS is a little more involved as MacOS enforces that all external programs are signed. KiCAD installed via homebrew is signed, however, once plugins with binary dependencies are installed, the signature gets invalidated. This prevents KiKit from running.
The current solution is to re-sign KiCAD after KiKit installation. Therefore, KiKit's installation on MacOS is twofold: - create a self-signed certificate - install KiKit and sign KiCAD
"},{"location":"installation/macos/#create-a-codesigning-certificate","title":"Create a codesigning certificate","text":"Open Keychain a select \"Create a Certificate\":
Then, enter name \"kikit\", select \"Self-Signed Root\" and type \"Code Signing\":
Confirm and the certificate is ready.
"},{"location":"installation/macos/#install-kikit-related-wrappers","title":"Install KiKit & related wrappers","text":"We provide a script for KiKit installation's, KiCAD signing and creating a wrapper script for KiKit. You can find the script here. You can download and run it. Open a terminal and enter:
$ curl -O https://raw.githubusercontent.com/yaqwsx/KiKit/master/scripts/installMacOS.bash\n$ sudo bash installMacOS.bash\nThe script will ask you for a password several times. Once it finishes, you can test it:
$ kikit --help\nUsage: python3 -m kikit.ui [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nOnce you install the PCM plugin, KiKit will be available via GUI in Pcbnew.
"},{"location":"installation/upgrading/","title":"Upgrading KiKit and installing special versions","text":""},{"location":"installation/upgrading/#upgrading-kikit","title":"Upgrading KiKit","text":"If you want to upgrade KiKit, you have to perform two steps:
pip install -U kikit in the command line (depending on the platform, see the installation instructions for individual platform).If you would like to install a specific version of KiKit (e.g., the upstream version), you can install it directly from git. The command for that is:
# The master branch (also called the upstream version) - the most up-to-date KiKit there is (but might me unstable)\npip install git+https://github.com/yaqwsx/KiKit@master\n# A concrete branch, e.g., from a pull request\npip3 install git+https://github.com/yaqwsx/KiKit@someBranchName\nTo install KiKit on Windows, you have to open \"KiCAD Command Prompt\". You can find it in the start menu:
Once you have it open like this:
you can put command in there and confirm them by pressing enter. This is also the prompt from which you will invoke all KiKit's CLI commands. They, unfortunately, does not work in an ordinary Command prompt due to the way KiCAD is packaged on Windows.
Then you have to enter the following command to install it:
pip install kikit\nNow you can test that it works:
kikit --help\nYou should get something like this:
Usage: kikit [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nNow you are done with the basic installation. Don't forget to get the GUI frontend and libraries via PCM.
"},{"location":"panelization/cli/","title":"Panelization CLI","text":"The whole panelization process of KiKit's CLI is driven by a configuration structure. The configuration contains several categories (e.g., layout, tabs, framing). Each of the categories have number of named parameters (e.g., tabsCount). All categories and their parameters are described further below.
Note that you can use the pcbnew action plugin to interactively construct the panelization configuration structure.
"},{"location":"panelization/cli/#configurations","title":"Configurations","text":"The configuration can be supplied to KiKit via a JSON file with comments and from the command line. The example of a configuration in a JSON file is the following
{\n // There can be C-like comments\n \"layout\": {\n \"type\": \"grid\",\n \"rows\": 1,\n \"cols\": 1,\n \"hspace\": \"0mm\",\n \"vspace\": \"0mm\",\n \"rotation\": \"0deg\",\n \"alternation\": \"none\",\n \"renamenet\": \"Board_{n}-{orig}\",\n \"renameref\": \"{orig}\"\n },\n \"source\": {\n \"type\": \"auto\",\n \"tolerance\": \"1mm\"\n },\n \"tabs\": {\n \"type\": \"normal\",\n \"source\": \"none\"\n },\n \"cuts\": {\n \"type\": \"none\"\n },\n \"framing\": {\n \"type\": \"none\",\n \"thickness\": \"0mm\",\n },\n \"post\": {\n \"type\": \"auto\",\n \"millradius\": \"0mm\",\n \"copperfill\": false\n }\n}\nKiKit accepts -p <configurationFile> option to specify one or more configurations. When multiple configurations are specified, they are composed into a single configuration. The later specified configurations overwrite parameters of the former specified configurations. This allows us to start with a basic configuration and have a number of small configurations specifying details.
To give and example, consider the two following configurations:
// A\n{\n \"tabs\": {\n \"type\": \"normal\",\n \"width\": \"3mm\"\n },\n \"framing\": {\n \"type\": \"frame\"\n }\n}\n\n// B\n{\n \"framing\": {\n \"type\": \"rails\"\n \"width\": \"5mm\"\n }\n}\nWhen we merge B into A, we get:
{\n \"tabs\": {\n \"type\": \"normal\",\n \"width\": \"3mm\"\n },\n \"framing\": {\n \"type\": \"rails\"\n \"width\": \"5mm\"\n }\n}\nYou can also override every parameter from CLI. There is an option for each category, which accepts a semicolon-separated list of key-value pairs; e.g.:
--layout 'rows: 3; cols: 4'\nThe options from CLI have the highest priority - they override values from specified from the files. If you need to specify the character ;, you can escape it via \\.
Therefore, a full invocation of KiKit for panelization can look like this:
kikit panelize -p myDefault.json -p useVcuts.json -p myFrame.json\n --layout 'rows: 3; cols: 4'\n board.kicad_pcb panel.kicad_pcb.\nNote the single quotes -- without them your shell will eat the spaces and the command will be interpreted badly. The command will use our default configuration, then it will override some options to use V-cuts and then it adds a frame specified by myFrame.json. Last we specify the panel size from CLI.
Note that KiKit always start with a default configuration (specified in the file default.json). There are also some configuration files shipped with KiKit. You can find them in the directory kikit/resources/panelizePresets. When you want to use them via option -p, just prefix their name with : and drop the suffix. E.g., for vcuts.json use -p :vcuts.
If you would like to inspect which configuration was used by KiKit, you can dump it into a file with the -d <filename> option.
You can specify units in the configuration files and CLI. Always specify them as string, e.g., \"2mm\" or \"0.5 inch\" (do not forget the quotes in the JSON files).
Supported length units: mm, cm, dm, m, mil, inch, in.
Supported angle units: deg, \u00b0, rad.
"},{"location":"panelization/cli/#configuration-categories","title":"Configuration categories","text":"There are the following categories: layout, source, tabs, cuts, framing, and tooling.
Each category has a mandatory parameter type which dictates the style of that feature. Note that you can specify the type parameter in a simplified manner in the CLI by specifying it first and omitting the type word; e.g., --cuts 'mousebites, someParameter: 10cm'.
Types: grid, plugin
Common options:
hspace, vspace, space: Specify the gap between the boards. You can specify separately vertical and horizontal spacing or you can specify space to make them the same (it has higher priority).rotation: Rotate the boards before placing them in the panelrenamenet, renameref: A pattern by which to rename the nets and references. You can use {n} and {orig} to get the board number and original name. Default values are Board_{n}-{orig} for nets and {orig} for references.baketext: A flag that indicates if text variables should be substituted or not.The boars are placed in a grid pattern connected by tabs. There are no special options.
rows, cols: Specify the number of boards in the grid patternalternation: Specify alternations of board rotation.none: Do not alternaterows: Rotate boards by 180\u00b0 on every next rowcols: Rotate boards by 180\u00b0 on every next columnrowsCols: Rotate boards by 180\u00b0 based on a chessboard patternvbackbone, hbackbone: The width of vertical and horizontal backbone (0 means no backbone). The backbone does not increase the spacing of the boards.vboneskip, hboneskip: Skip every n backbones. I.e., 1 means place only every other backbone.vbonefirst, hbonefirst: Specify first backbone to render. Allows to specify the offset when skipping backbones. The offset is indexed from 1.vbonecut, hbonecut: true/false. If there are both backbones specified, specifies if there should be a vertical or horizontal cut (or both) where the backbones cross.Implements a custom layout based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginThis option allows you to specify the source area, e.g., when multiple boards are present. You can read more about multi-board project here.
Types: auto, rectangle, annotation
Common options:
stack: specify the number of layers of the panel. Valid options are 2layer, 4layer, 6layer or inehrit (default). The use case for this option is when you design a multiple boards in a single desing and you separate them, however, one boards is e.g., 4 layer and one 2 layer. Then you design both of them as 4 layer and you specify stack: 2layer for the 2 layer one when panelizing or separating.Find all board edges and use them to construct source rectangle. Suitable for most cases when there is only a single board in the design. Note that might want to increase tolerance or specify the source area explicitly via rectangle if you have components sticking out of your design.
tolerance: KiKit extracts only board items that fit fully into the source area (including all drawings on all layers). Tolerance enlarges the source area by given amount, to e.g., not omit KiKit annotations for tabs or connectors sticking out of the board.Specify the source rectangle explicitly.
tlx, tly, brx, bry: specify the coordinates (via length units) of the rectangle via top-left and bottom-right corner.KiKit offers you to place an annotation footprint kikit:Board into your design file to name the board. The area is determined by a bounding box of the lines in the Edge.Cuts layer that the arrows point to. Note that the tip of the arrow must lie on the PCB edge or slightly outside of it.
ref: specify the annotation symbol referencetolerance: see aboveTypes: fixed, spacing, full, annotation, plugin
Place tabs. To make some of the options clear, please see the explanation of tab placement process.
"},{"location":"panelization/cli/#fixed","title":"Fixed","text":"Place given number of tabs on the PCB edge. The tabs are spaced uniformly. If you need a custom tab placement (e.g., to avoid critical feature), see type annotation.
vwidth, hwidth, width: The width of tabs in the vertical and horizontal direction. width overrides both.vcount, hcount: Number of tabs in a given direction.mindistance: Minimal spacing between the tabs. If there are too many tabs, their count is reduced.Place tabs on the PCB edges based on spacing.
vwidth, hwidth, width: The width of tabs in the vertical and horizontal direction. width overrides both.spacing: The maximum spacing of the tabs.Create tabs that are full width of the PCB. Suitable for PCBs separated by V-Cuts. This mode does not make much sense for mousebites in practice. Note that in this mode the cuts do not faithfully copy the PCB outline and, instead, they cut the bounding box of the PCB. There are no other options.
cutout: When your design features open pockets on the side, this parameter specifies extra cutout depth in order to ensure that a sharp corner of the pocket can be milled. The default is 1\u00a0mm.patchcorners: The full tabs are appended to the nearest flat face of the PCB. If the PCB has sharp corners, you want to add patches of substrate to these corners. However, if the PCB has fillet or miter, you don't want to apply the patches.Create tabs in the corners of the PCB.
width: The width of tabsAdd tabs based on PCB annotations. Place a footprint kikit:Tab at the edges of your PCB. You can edit the text field prefixed with KIKIT: to adjust the tab parameters. If you want to specify a custom tab symbol (e.g., with predefined) width, you can specify tabfootprints as a list of footprints separated by comma. For example: myLib:Tab2mm, myLib:Tab3mm.
The individual tabs can have the following properties specified in the text field of the component as KIKIT:<propertyname>:
width: width of the tab.Tabs based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginSpecify how to perform the cuts on the tabs separating the board.
Types: none, mousebites, vcuts, layer, plugin
"},{"location":"panelization/cli/#none","title":"None","text":"Do not perform any cuts
"},{"location":"panelization/cli/#mousebites","title":"Mousebites","text":"Use mousebites to
drill - specify drill size for the bitesspacing - specify the spacing of the holesoffset - specify the offset, positive offset puts the cuts into the board, negative puts the cuts into the tabsprolong - distance for tangential prolongation of the cuts (to cut through the internal corner fillets caused by milling)clearance - specify clearance for copper around V-cutscutcurves - true/false - specify if curves should be approximated by straight cuts (e.g., for cutting tabs on circular boards)offset - specify the offset, positive offset puts the cuts into the board, negative puts the cuts into the tabslayer - specify the layer to render V-cuts on.linewidth - specify linewidthendprolongation - prolongation of the cut line from the board line on the side without text.textprolongation - the same as above, just on the text sidetextoffset - offset of the text from the cut linetemplate - a string template for text to render. Can contain variables listed below, e.g., V-CUT {pos_mm}.pos_mm, pos_inch \u2013 position of the V-cut from the panel originpos_inv_mm, pos_inv_inch \u2013 inverted position of the V-cut from the panel originWhen KiKit reports it cannot perform cuts, you can render the cuts into a layer with this option to understand what's going on. Shouldn't be used for the final design.
layer - specify the layer to render the cuts on.prolong - distance for tangential prolongation of the cuts. It has the same meaning as mousebites.linewidth - width of line to renderCuts based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginKiKit allows you to frame the panel with a full frame, or bottom/top or left/right rails.
Types: none, railstb, railslr, frame, tightframe, plugin Common options:
hspace, vspace, space - specify the space between PCB and the frame/rail. space overrides hspace and vspace.width - specify with of the rails or framefillet, chamfer - fillet/chamfer frame corners. Specify radius or chamfer size. You can also separately specify chamferwidth and chamferheight to create a non 45\u00b0 chamfer.mintotalheight, mintotalwidth \u2013 if needed, add extra material to the rail or frame to meet the minimal requested size. Useful for services that require minimal panel size.Add rail (either on top and bottom or on left and right) to the panel.
"},{"location":"panelization/cli/#frame","title":"Frame","text":"Add a frame around the board.
cuts - one of none, both, v, h - specify whether to add cuts to the corners of the frame for easy removal. Default both.Add a frame around the board which fills the whole area of the panel - the boards have just a milled slot around their perimeter.
slotwidth - width of the milled slot.Frame based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd tooling holes to the (rail/frame of) the panel. The holes are positioned by
Types: none, 3hole, 4hole, plugin
Common options:
hoffset, voffset - specify the offset from from panel edgessize - diameter of the holespaste - if true, the holes are included in the paste layer (therefore they appear on the stencil).solderMaskMargin - diameter of solder mask (optional)Tooling based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd fiducial to the (rail/frame of) the panel.
Types: none, 3fid, 4fid, plugin
Common options:
hoffset, voffset - specify the offset from from panel edgescoppersize, opening - diameter of the copper spot and solder mask openingpaste - if true, the fiducials are included in the paste layer (therefore they appear on the stencil).Fiducials based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd text to the panel. Allows you to put a single block of text on panel. You can use variables enclosed in {}. E.g. {boardTitle} | {boardDate}. The list of all available variables in listed bellow. You can also use the variables specified in the project. They are prefixed with user-. That is, to include your variable revision in KiKit text, use formatting string Rev: {user-revision}. In the case you need more independent texts on the panel, you can use sections names text2, text3 and text3 to add at most 4 text. All these sections behave the same and accept the same options.
If you need more texts or more sophisticated placing options, see script option from postprocess.
Types: none, simple
Common options:
text - The text to be displayed. Note that you can escape ; via \\anchor - Origin of the text. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). The anchors refer to the panel outline. Default mthoffset, voffset - specify the offset from anchor. Respects KiCAD coordinate system. Default 0mm.orientation - specify the orientation (angle). Default 0degwidth, height - width and height of the characters (the same parameters as KiCAD uses). Default 1.5mm.hjustify - justification of the text. One of left, right, center. Default center.vjustify - justification of the text. One of top, bottom, center. Default centerthickness - stroke thickness. Default 0.3mm.layer - specify text layerplugin - specify the plugin that provides extra variables for the textdate - formats current date as <year>-<month>-<day>time24 - formats current time in 24-hour formatyear, month, day, hour, minute, second - individual variables for any date formatboardTitle - the title from the source boardboardDate - the date from the source boardboardRevision - the revision from the source boardboardCompany - the company from the source boardboardComment1-boardComment9 - comments from the source boardYou can get extra variables by providing custom text plugin via the plugin field.
Sets page size on the resulting panel and position the panel in the page. The type of style dictates paper size. The default inherit option inherits paper size from the source board. This feature is not supported on KiCAD 5
Types: inherit, custom, A0, A1, A2, A3, A4, A5, A, B, C, D, E, USLetter, USLegal, USLedger, A0-portrait, A1-portrait, A2-portrait, A3-portrait, A4-portrait, A5-portrait, A-portrait, B-portrait, C-portrait, D-portrait, E-portrait, USLetter-portrait, USLegal-portrait, USLedger-portrait
Common options:
anchor - Point of the panel to be placed at given position. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). The anchors refer to the panel outline. Default mtposx, posy - the position of the panel on the page. Default 50% for posx and 20mm for posy.Instead of the pre-defined paper size you can also specify a custom paper size via width and height.
Fill non-board areas of the panel with copper.
Types: none, solid, hatched, hex
Common options:
clearance - optional extra clearance from the board perimeters. Suitable for, e.g., not filling the tabs with copper.edgeclearance - specifies clearance between the fill and panel perimeter.layers - comma-separated list of layer to fill. Default top and bottom. You can specify a shortcut all to fill all layers.Fill with solid copper.
"},{"location":"panelization/cli/#hatched","title":"Hatched","text":"Use hatch pattern for the fill.
width - the width of the strokesspacing - the space between the strokesorientation - the orientation of the strokesUse hexagon pattern for the fill.
diameter \u2013 diameter of the hexagonsspacing \u2013 space between the hexagonsthreshold \u2013 a percentage value that will discard fragments smaller than given thresholdFinishing touches to the panel.
Types: auto
Common options:
copperfill - fill tabs and frame with copper (e.g., to save etchant or to increase rigidity of flex-PCB panels)millradius - simulate the milling operation (add fillets to the internal corners). Specify mill radius (usually 1 mm). 0 radius disables the functionality.millradiusouter \u00ad\u2013 same as the previous one, modifies only board outer counter. No internal features of the board are affected.reconstructarcs - the panelization process works on top of a polygonal representation of the board. This options allows to reconstruct the arcs in the design before saving the panel.refillzones \u2013 refill the user zones after the panel is build. This is only necessary when you want your zones to avoid cuts in panel.script - a path to custom Python file. The file should contain a function kikitPostprocess(panel, args) that receives the prepared panel as the kikit.panelize.Panel object and the user-supplied arguments as a string - see scriptarg. The function can make arbitrary changes to the panel - you can append text, footprints, alter labels, etc. The function is invoked after the whole panel is constructed (including all other postprocessing). If you try to add a functionality for a common fabrication houses via scripting, consider submitting PR for KiKit.scriptarg: An arbitrary string passed to the user post-processing script specified in scriptorigin - specify if the auxilary origin an grid origin should be placed. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). Empty string does not changes the origin.dimensions - true or false. Draw dimensions with the panel size.edgewidth \u00ad\u2013 width of the line for panel edges (that is the lines in the Edge.Cuts layer).This document will show you several examples of KiKit CLI for panelization. Note that this is not an exhaustive description of everything that KiKit can do, nor proper documentation. For further details, please refer to:
We will show everything on a single board located in docs/resources/conn.kicad_pcb. The board looks like this when rendered via PcbDraw:
Let's start with our first panel.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2;' \\\n --tabs full \\\n --cuts vcuts \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2;\" ^\n --tabs full ^\n --cuts vcuts ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe specified that we want 2x2 panel, no space between board and separate them by V-cuts. We also specified that we want to build full tabs (although no tabs are visible in this example). This is ,however, essential \u2013 if we omitted tabs, no cuts between the boards would be performed. Note, that due to the rounded corners, this panel cannot be manufactured. We will fix it later.
Note that the \\ in the input is there to make shell happy, so we can break our command into multiple lines. Also note that there are single quotes around the key-value pair \u2013 again, to make shell happy and to interpret a string with spaces as a single option.
Note that on Windows you have the enter the commands into KiCAD Command Prompt instead of the regular Command Prompt. You can find it under the Start menu.
Also note that KiKit accepts all options in categories (e.g., layout, tabs, cuts, ...). You can specify the parameters as a semicolon-separated key-value list. To learn about the precise syntax of the CLI and about all options, please refer to \u2013 documentation.
One side note \u2013 if you try it with your own board some components might be gone. KiKit respects the KiCAD component selection criteria. When you specify an input rectangle, only the components that fully fit inside the input rectangle are selected. This however take in account both name and value labels (even when they are hidden).
When you do not specify the source are explicitly, KiKit takes the board outline bounding box as the source area. Therefore, by default, components outside the board substrate are not copied to panel.
Note that this is intended behavior; for once it is consistent with KiCAD behavior of user selection and also it allows to easily ignore surrounding comments and drawings in the board sheet (it makes no sense to have 12 same copies of the notes around the board).
How to include the missing components? - specify the source area explicitly to include all your components - specify --source 'tolerance: 10mm' to enlarge the board outline bounding box by e.g. 10 mm. The default value is 1 mm.
I told you that the panel above is not suitable for manufacturing. Let's see why:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2;' \\\n --tabs full \\\n --cuts vcuts \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2;\" ^\n --tabs full ^\n --cuts vcuts ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe specified a milling simulation post-processing. This simulates the milling operation in the fab house. As you can see, the sharp internal corners cannot be manufactured. I recommend you to use milling postprocessing always \u2013 you can easily see if your cuts are off or you have too narrow slots in your design.
Usually, one would use full tabs only for rectangular boards. Usually, when you have rounded corners, you will use short tabs instead and add some space between the boards. So let's fix it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; hwidth: 10mm; vwidth: 15mm' \\\n --cuts vcuts \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; hwidth: 10mm; vwidth: 15mm\" ^\n --cuts vcuts ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIn that way, the rounded corners can be machined. Lets' see the same example with mousebites instead:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 5mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 5mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe changed cut type to mousebites and we specified that they should be performed by 0.5mm holes with a spacing of 1 mm. You could also use inches if you want \u2013 just specify `in. Since we use mousebites, we used narrower tabs. We also specified that the cuts should be inset 0.25 mm into the board outline. This is suitable when your board should fit into a cover \u2013 when you break away the tabs, all burs will be inside the intended board outline.
What happens, when we simulate the milling operation?
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 5mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 5mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSee? The cuts are somewhat short. This is due to the internal corners that cannot be milled. KiKit can fix that for you \u2013 just specify you want to prolong your cuts tangentially by a small amount:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you want, you can also specify a number of tabs to generate. KiKit will place them evenly:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nYou can also append frame or rails to the panel. Frames and rail are useful in the following situations:
Let's start with rails:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSimilarly, you can add left and right rail via the railslr type. If you want a full frame, use the type frame. When you place a full frame, it might make sense to include cuts in the corner of the frame, so you can break it apart easily. Let's see an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote that you can also use just only a vertical or horizontal frame cuts:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: h' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: h\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen you use V-cuts it might make sense to not remove all material, but only mill a slot around the board of the board. This yields a stronger panel \u2013 and some manufacturers require such style for assembly with V-Cuts. This is achieved via framing type tightframe. Note that it does not make much sense with mousebites.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 6mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts vcuts \\\n --framing 'tightframe; width: 5mm; space: 3mm; ' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 6mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts vcuts ^\n --framing \"tightframe; width: 5mm; space: 3mm; \" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nOnce we have a frame, we can append a tooling holes, fiducials and some text to it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you want to add text to both rails, you can use section --text2 to add a second text. You can also use variables enclosed in curly brackets ({}). The list of supported variables is listed in the documentation. Also, plugins can introduce new variables.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --text2 'simple; text: Created on {date}; anchor: mb; voffset: -2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --text2 \"simple; text: Created on {date}; anchor: mb; voffset: -2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nThere are many options for text and fiducials. Be sure to read the full documentation.
If you have an automatic feeder in your PNP machine or you just dislike sharp corners, you can add a chamfer or a fillet to the panel frame/rails:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm; fillet: 1mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm; fillet: 1mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nPanelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm; chamfer: 1mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm; chamfer: 1mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSome services, e.g., JLC PCB require a minimal panel size. If you want to ensure that your panel meets the criteria, you can specify minimal total width/height of the panel. Let's see an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; mintotalheight: 100mm; mintotalwidth: 100mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel with minimal dimensions; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; mintotalheight: 100mm; mintotalwidth: 100mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel with minimal dimensions; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIt is possible that you have some critical features you want to avoid with tabs. KiKit has several features that can help you. Let's start with the simple ones.
First, you can rotate the boards in your layout. This might make not much sense for rectanglar boards, but it might save you when you have circular or oddly shaped boards:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 0mm; rotation: 45deg;' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.75mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 0mm; rotation: 45deg;\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.75mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen your board has a connector sticking one one side of the board, it makes sense to rotate the boards every other column, row or combination of both. KiKit supports this via layout option alternation. You should be careful about component references when rotating boards \u2013 KiCAD's references have a property \"Stay upright\" which makes them always face up (even when placed on a panel). So be sure to turn it off before panelizing. Here's an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 3mm; alternation: cols;' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 3mm; alternation: cols;\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nAnother solution might be to not put tabs on, e.g., vertical edges of the PCB. However, in that case your panel might be weak for further assembly. You can make it more stiff by including backbones \u2013 a full piece of substrate between the panels. You can add either vertical, horizontal or both backbones. Also, similarly with frames, you can put cuts on your backbone to make depanelization of your boards easier. Enough theory, let's see an example
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm; hbackbone: 5mm; hbonecut: true' \\\n --tabs 'fixed; width: 3mm; vcount: 2; hcount: 0' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm; hbackbone: 5mm; hbonecut: true\" ^\n --tabs \"fixed; width: 3mm; vcount: 2; hcount: 0\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nOften, not all backbones are needed. Especially for larger panels. Therefore, if you want, you can skip some of them. Consider the following 4\u00d74 panel with only ever other backbone:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 4; cols: 4; space: 2mm; hbackbone: 5mm; vbackbone: 5mm; hboneskip: 1; vboneskip: 1' \\\n --tabs 'fixed; width: 3mm; vcount: 2; hcount: 0' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 4; cols: 4; space: 2mm; hbackbone: 5mm; vbackbone: 5mm; hboneskip: 1; vboneskip: 1\" ^\n --tabs \"fixed; width: 3mm; vcount: 2; hcount: 0\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nThe most powerful feature of KiKit regarding tab placement are tabs via annotation. Remember our test board? When you open it in Pcbnew, you can see that there are some special footprints \u2013 KiKit's annotations:
They specify where to place tabs. You can even specify individual tab width via text property of the symbol. How to use it? Just specify tab type to annotation. We also have to increase the source area tolerance, so it can capture the annotations.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 5mm;' \\\n --tabs annotation \\\n --source 'tolerance: 15mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 5mm;\" ^\n --tabs annotation ^\n --source \"tolerance: 15mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWell, the panel looks strange \u2013 right? That's because KiKit always constructs a half-bridges. When you specify the tabs location, you have to either ensure they match or put a piece of substrate they can reach \u2013 e.g., a backbone or a tightframe. If you are interested in the details, read more about tabs in section Understanding tabs. Let's fix it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm; hbackbone: 3mm; vbackbone: 3mm' \\\n --tabs annotation \\\n --source 'tolerance: 15mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm; hbackbone: 3mm; vbackbone: 3mm\" ^\n --tabs annotation ^\n --source \"tolerance: 15mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote that the annotation can have an arbitrary orientation. The arrow just must be outside board edge and points towards it. KiKit will also place only those tabs, that have a neighboring substrate. For precise algorithm, see section understanding tabs.
When you make flex PCBs or you want to save etchant, it make sense to pour copper on all non-functional parts of the panel. It will make the PCB rigid. You can do so via copperfill section:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill solid \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill solid ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen you use V-cuts with copperfill you (or your fab house) might want to include a clearance around the V-cuts:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; hwidth: 10mm; vwidth: 15mm' \\\n --cuts 'vcuts; clearance: 1.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill solid \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; hwidth: 10mm; vwidth: 15mm\" ^\n --cuts \"vcuts; clearance: 1.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill solid ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you, for example do not wish to cover the tabs with copper, you can also specify clearance. Also, some manufacturers don't like when you have large solid copper areas. In that case, you can use a hatch pattern to fill the area:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill 'hatched; clearance: 2mm; spacing: 0.5mm; width: 0.5mm' \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill \"hatched; clearance: 2mm; spacing: 0.5mm; width: 0.5mm\" ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote one last facts about V-cuts. V-cuts can only be straight and horizontal/vertical. But you can use them with circular boards if you want by cutting a little inside them. The option cutcurves, that will approximate the cut by staring and ending point.
If you need something special; e.g., custom placement of tooling holes, multiple texts, etc. KiKit has you covered.
The CLI interface allows you to run a custom script over the final panel. The script can use KiKit Python interface to modify it. For the sake of simplicity, let's add a hole in the middle of the frame. Therefore, we write the following script:
from kikit.units import mm\nfrom kikit.common import toKiCADPoint\n\ndef kikitPostprocess(panel, arg):\n minx, miny, maxx, maxy = panel.panelBBox()\n position = toKiCADPoint(((minx + maxx) // 2, miny + 2 * mm))\n panel.addNPTHole(position, 3 * mm)\nThen run KiKit:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm; script: docs/resources/examplePost.py' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm; script: docs/resources/examplePost.py\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nYou can learn more about available functions from the comment in the source code or in the Python API reference. The basic concepts are summarized in the scripting guide.
If you implement a feature that your fab house requires (e.g., new tooling hole type), consider submitting a pull request for KiKit instead. I believe the others will benefit from it.
"},{"location":"panelization/examples/#managing-presets","title":"Managing presets","text":"The last section of this document is dedicated to management of presets. You can read the specification in the documentation for CLI. Here I would like to focus on practical examples.
As you should know from the documentation, the panelization preset is divided into sections; e. g., layout, tabs, etc. The key-value parameters in these sections can be specified via JSON files. In KiKit, you can specify these files via -p option:
kikit panelize -p myPreset.json -p :<builtInPreset> <other parameters>
The parameters in the later specified presets override the parameters in the previously specified presets. This allows you to define a named piece-wise presets. Therefore, you can prepare various presets for mousebites \u2013 e.g., fineMousebites.json and coarseMousebites.json:
// fineMousebites.json\n{\n \"cuts\": {\n \"type\": \"mousebites\", \"drill\": \"0.5mm\", \"spacing\": \"0.9mm\", \"offset\":\n \"0.25mm\"\n }\n}\n\n// coarseMousebites.json\n{\n \"cuts\": {\n \"type\": \"mousebites\", \"drill\": \"0.3mm\", \"spacing\": \"0.2mm\", \"offset\":\n \"0.15mm\"\n }\n}\nThen you can specify your panelization commands easily via:
kikit panelize -p fineMousebites.json <otheroptions>
Therefore, you can build a custom library of commonly used-options; e.g., per fabrication house. KiKit offers some built-in presets \u2013 see panelizePresets. Note that the built-in preset default.json is always used as a base and it specifies conservative default values so you can only override the options relevant for you.
To give you an example \u2013 with KiKit, you will no longer have to remember what diameter of tooling holes JLC PCB requires, just use:
kikit panelize -p :jlcTooling <otheroptions>
The panelization feature of KiKit is also available via GUI in the KiCAD's PCB editor (Pcbnew). The main use-case for the GUI is to quickly construct the desired KiKit command and fine-tune the panel. It also serves as a quick help in case you are not sure about parameter naming.
The GUI is designed to be run in a standalone instance of Pcbnew (not executed from a project) as the generated panel replaces the currently open board.
You can invoke the GUI via clicking on the panelization icon:
Then the following window will open:
There are three parts of the window:
Note that both, the command and JSON preset, does not include a parameter if it is the same with the default, built-in, preset.
Once you are happy with the parameters, you can click the \"Panelize\" button and the panel will appear in the Pcbnew work area. You can then edit the parameters and regenerate the panel. The panel you see in the Pcbnew window is only a preview. The panel is automatically saved to the specified location upon creation.
"},{"location":"panelization/intro/","title":"Automatic panelization with KiKit","text":"KiKit panelization module is designed to:
There are two ways of specifying a panel:
To tweak the KiKit UI process it is possible to use plugins. Plugins are pieces of Python code that provide some functionality. They can save you from writing a custom panelization script from scratch when you only need a custom one of the steps during panelization.
"},{"location":"panelization/plugins/#specifying-plugins","title":"Specifying plugins","text":"Some of the CLI options allow you to specify plugin. In such a case, one of the following formats is expected:
<packagename>.<pluginname>, e.g., ExternalPackage.CircleLayout<filename>.<pluginname>, e.g., localFile.py.CircleLayoutAll plugins, except text plugins, accept optional user text argument.
The plugins can be implemented and published as Python packages.
"},{"location":"panelization/plugins/#writing-custom-plugins","title":"Writing custom plugins","text":"The plugins should be implemented by overriding one of the plugin types specified in ../kikit/plugin.py. Currently, the following plugin types are supported:
HookPlugin - this is a plugin that features a number of callback that are invoked during various stages of building the panel. You can tweak the panels in these callbacks.LayoutPlugin - this plugin implements a new layout of the boards in the panel.FramingPlugin - this plugin implements a new style of framing.TabsPlugin - this plugin implements a new style of tab placement.CutsPlugin - this plugin implements a new style of cut rendering.ToolingPlugin - this plugin implements a new style of tolling decoration.FiducialsPlugin - this plugin implements a new style of fiducials decoration.TextVariablePlugin - this plugins provides new variables for the text placement.All plugins except TextVariablePlugin have attributes self.preset containing the whole preset and self.userArg containing the string provided by the user.
When you want to panelize a board, you are expected to load the kikit.panelize module and create an instance of the Panel class.
All units are in the internal KiCAD units (1 nm). You can use predefined constants to convert from/to them:
from kikit.units import *\n\nl = 1 * mm # 1 mm\nl = 42 * inch # 42 inches\nl = 15 * cm # 15 cm\na = 90 * deg # 90\u00b0\na = 1 * rad # 1 radian\nYou can also use functions fromMm(mm) and toMm(kiUnits) to convert to/from them if you like them more. You are also encouraged to use the functions and objects the native KiCAD Python API offers, e.g.: VECTOR2I(args),BOX2I(args).
The kikit.panelize.Panel class holds a panel under construction. Basically it is pcbnew.BOARD without outlines. The outlines are held separately as shapely.MultiPolygon so we can easily merge pieces of a substrate, add cuts and export it back to pcbnew.BOARD. This is all handled by the class kikit.substrate.Substrate.
There are two ways to create tabs: generate a piece of a substrate by hand, or use tab generator.
To generate a piece of a substrate, create a shapely.Polygon. Then add the piece of substrate via panelize.Panel.appendSubstrate. This method also accepts a BOX2I for convenience.
The tab generator is available via panelize.Panel.boardSubstrate.tab. This method takes an origin point, direction, and tab width. It tries to build a tab by extruding a tab with the given width in the given direction and stops when it reaches an existing substrate. It returns a tuple - the tab substrate and a piece of the outline of the original board, which was removed by the tab. Then add the piece of a substrate via panelize.Panel.appendSubstrate. This design choice was made as batch adding of substrates is more efficient. Therefore, you are advised to first generate all the tabs and then append them to the board.
You read more about the algorithms for generating tabs in a separate document understanding tabs.
"},{"location":"panelization/python_api/#cuts","title":"Cuts","text":"All methods constructing panels do not create cuts directly, instead, they return them. This allows the users to decided how to perform the cuts - e.g., mouse bites, V-Cuts, silk-screen...
The cuts are represented by shapely.LineString. The string is oriented - a positive side of the string should face the inner side of the board. This is important when, e.g., offsetting mouse bites.
To perform the cuts, see methods of the panelize.Panel class below.
When placing a board, you might specify source area -- a rectangle from which the components are extracted. If no source area is specified, the smallest bounding box of all Edge.Cuts is taken.
Only components that fully fit inside source area are copied to the panel. To include components sticking out of the board outline, you can specify tolerance -- a distance by which the source area is expanded when copying components.
"},{"location":"panelization/python_api/#appendboard","title":"appendBoard","text":"appendBoard(self, filename, destination, sourceArea=None, origin=Origin.Center, \n rotationAngle=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3120> >, \n shrink=False, tolerance=0, bufferOutline=1000, netRenamer=None, \n refRenamer=None, inheritDrc=True, interpretAnnotations=True, \n bakeText=False)\nThis class has the following relevant members: - board - pcbnew.BOARD of the panel. Does not contain any edges. - substrates - kikit.substrate.Substrate - individual substrates appended via None. You can use them to get the original outline (and e.g., generate tabs accroding to it). - boardSubstrate - kikit.substrate.Substrate of the whole panel. - backboneLines - a list of lines representing backbone candidates. Read more about it in understanding tabs.
addCornerChamfers","text":"addCornerChamfers(self, horizontalSize, verticalSize=None)\naddCornerFiducials","text":"addCornerFiducials(self, fidCount, horizontalOffset, verticalOffset, \n copperDiameter, openingDiameter, paste=False)\nThe offsets are measured from the outer edges of the substrate.
"},{"location":"panelization/python_api/#addcornerfillets","title":"addCornerFillets","text":"addCornerFillets(self, radius)\naddCornerTooling","text":"addCornerTooling(self, holeCount, horizontalOffset, verticalOffset, diameter, \n paste=False, solderMaskMargin=None)\nThe offsets are measured from the outer edges of the substrate.
Optionally, a solder mask margin (diameter) can also be specified.
"},{"location":"panelization/python_api/#addfiducial","title":"addFiducial","text":"addFiducial(self, position, copperDiameter, openingDiameter, bottom=False, \n paste=False, ref=None)\nVECTOR2I), with given copperDiameter and openingDiameter. By setting bottom to True, the fiducial is placed on bottom side. The fiducial can also have an opening on the stencil. This is enabled by paste = True."},{"location":"panelization/python_api/#addkeepout","title":"addKeepout","text":"addKeepout(self, area, noTracks=True, noVias=True, noCopper=True)\naddLine","text":"addLine(self, start, end, thickness, layer)\naddMillFillets","text":"addMillFillets(self, millRadius)\naddNPTHole","text":"addNPTHole(self, position, diameter, paste=False, ref=None, \n excludedFromPos=False)\nVECTOR2I) with given diameter. The paste option allows to place the hole on the paste layers."},{"location":"panelization/python_api/#addpaneldimensions","title":"addPanelDimensions","text":"addPanelDimensions(self, layer, offset)\naddTabMillFillets","text":"addTabMillFillets(self, millRadius)\naddText","text":"addText(self, text, position, \n orientation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f37b0> >, \n width=1500000, height=1500000, thickness=300000, \n hJustify=EDA_TEXT_HJUSTIFY_T.GR_TEXT_HJUSTIFY_CENTER, \n vJustify=EDA_TEXT_VJUSTIFY_T.GR_TEXT_VJUSTIFY_CENTER, \n layer=Layer.F_SilkS)\naddVCutH","text":"addVCutH(self, pos)\naddVCutV","text":"addVCutV(self, pos)\nappendBoard","text":"appendBoard(self, filename, destination, sourceArea=None, origin=Origin.Center, \n rotationAngle=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3120> >, \n shrink=False, tolerance=0, bufferOutline=1000, netRenamer=None, \n refRenamer=None, inheritDrc=True, interpretAnnotations=True, \n bakeText=False)\nThe sourceArea (BOX2I) of the board specified by filename is extracted and placed at destination (VECTOR2I). The source area (BOX2I) can be auto detected if it is not provided. Only board items which fit entirely into the source area are selected. You can also specify rotation. Both translation and rotation origin are specified by origin. Origin specifies which point of the sourceArea is used for translation and rotation (origin it is placed to destination). It is possible to specify coarse source area and automatically shrink it if shrink is True. Tolerance enlarges (even shrinked) source area - useful for inclusion of filled zones which can reach out of the board edges or footprints that extend outside the board outline, like connectors.
You can also specify functions which will rename the net and ref names. By default, nets are renamed to \"Board_{n}-{orig}\", refs are unchanged. The renamers are given board seq number and original name.
You can also decide whether you would like to inherit design rules from this boards or not.
Similarly, you can substitute variables in the text via bakeText.
Returns bounding box (BOX2I) of the extracted area placed at the destination and the extracted substrate of the board.
"},{"location":"panelization/python_api/#appendsubstrate","title":"appendSubstrate","text":"appendSubstrate(self, substrate)\napply","text":"apply(self, feature)\nboardsBBox","text":"boardsBBox(self)\nbuildFullTabs","text":"buildFullTabs(self, cutoutDepth, patchCorners=True)\nReturn a list of cuts.
"},{"location":"panelization/python_api/#buildpartitionlinefrombb","title":"buildPartitionLineFromBB","text":"buildPartitionLineFromBB(self, boundarySubstrates=[], safeMargin=0)\nbuildTabAnnotationsCorners","text":"buildTabAnnotationsCorners(self, width)\nbuildTabAnnotationsFixed","text":"buildTabAnnotationsFixed(self, hcount, vcount, hwidth, vwidth, minDistance, \n ghostSubstrates)\nIf the edge is short for the specified number of tabs with given minimal spacing, the count is reduced.
You can also specify ghost substrates (for the future framing).
"},{"location":"panelization/python_api/#buildtabannotationsspacing","title":"buildTabAnnotationsSpacing","text":"buildTabAnnotationsSpacing(self, spacing, hwidth, vwidth, ghostSubstrates)\nYou can also specify ghost substrates (for the future framing).
"},{"location":"panelization/python_api/#buildtabsfromannotations","title":"buildTabsFromAnnotations","text":"buildTabsFromAnnotations(self, fillet)\nExpects that a valid partition line is assigned to the the panel.
"},{"location":"panelization/python_api/#cleartabsannotations","title":"clearTabsAnnotations","text":"clearTabsAnnotations(self)\ncopperFillNonBoardAreas","text":"copperFillNonBoardAreas(self, clearance=1000000, \n layers=[<Layer.F_Cu: 0>, <Layer.B_Cu: 31>], \n hatched=False, strokeWidth=1000000, \n strokeSpacing=1000000, \n orientation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3510> >)\nFill given layers with copper on unused areas of the panel (frame, rails and tabs). You can specify the clearance, if it should be hatched (default is solid) or shape the strokes of hatched pattern.
By default, fills top and bottom layer, but you can specify any other copper layer that is enabled.
"},{"location":"panelization/python_api/#debugrenderbackbonelines","title":"debugRenderBackboneLines","text":"debugRenderBackboneLines(self)\ndebugRenderBoundingBoxes","text":"debugRenderBoundingBoxes(self)\ndebugRenderPartitionLines","text":"debugRenderPartitionLines(self)\ngetAuxiliaryOrigin","text":"getAuxiliaryOrigin(self)\ngetDruFilepath","text":"getDruFilepath(self, path=None)\ngetGridOrigin","text":"getGridOrigin(self)\ngetPageDimensions","text":"getPageDimensions(self)\ngetPrlFilepath","text":"getPrlFilepath(self, path=None)\ngetProFilepath","text":"getProFilepath(self, path=None)\ninheritCopperLayers","text":"inheritCopperLayers(self, board)\ninheritDesignSettings","text":"inheritDesignSettings(self, board)\ninheritPageSize","text":"inheritPageSize(self, board)\ninheritProperties","text":"inheritProperties(self, board)\ninheritTitleBlock","text":"inheritTitleBlock(self, board)\nlocateBoard","text":"locateBoard(inputFilename, expandDist=None)\nParameters:
inputFilename - the path to the board file
expandDist - the distance by which to expand the board outline in each direction to ensure elements that are outside the board are included
"},{"location":"panelization/python_api/#makecutstolayer","title":"makeCutsToLayer","text":"makeCutsToLayer(self, cuts, layer=Layer.Cmts_User, prolongation=0)\nThe purpose of this is to aid debugging when KiKit refuses to perform cuts. Rendering them into lines can give the user better understanding of where is the problem.
"},{"location":"panelization/python_api/#makeframe","title":"makeFrame","text":"makeFrame(self, width, hspace, vspace, minWidth=0, minHeight=0, maxWidth=None, \n maxHeight=None)\nParameters:
width - width of substrate around board outlines
slotwidth - width of milled-out perimeter around board outline
hspace - horizontal space between board outline and substrate
vspace - vertical space between board outline and substrate
minWidth - if the panel doesn't meet this width, it is extended
minHeight - if the panel doesn't meet this height, it is extended
maxWidth - if the panel doesn't meet this width, TooLargeError is raised
maxHeight - if the panel doesn't meet this height, TooLargeHeight is raised
"},{"location":"panelization/python_api/#makeframecutsh","title":"makeFrameCutsH","text":"makeFrameCutsH(self, innerArea, frameInnerArea, outerArea)\nmakeFrameCutsV","text":"makeFrameCutsV(self, innerArea, frameInnerArea, outerArea)\nmakeGrid","text":"makeGrid(self, boardfile, sourceArea, rows, cols, destination, placer, \n rotation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3f00> >, \n netRenamePattern=Board_{n}-{orig}, refRenamePattern=Board_{n}-{orig}, \n tolerance=0, bakeText=False)\nParameters:
boardfile - the path to the filename of the board to be added
sourceArea - the region within the file specified to be selected (see also tolerance, below) set to None to automatically calculate the board area from the board file with the given tolerance
rows - the number of boards to place in the vertical direction
cols - the number of boards to place in the horizontal direction
destination - the center coordinates of the first board in the grid (for example, VECTOR2I(100 * mm, 50 * mm))
rotation - the rotation angle to be applied to the source board before placing it
placer - the placement rules for boards. The builtin classes are: BasicGridPosition - places each board in its original orientation OddEvenColumnPosition - every second column has the boards rotated by 180 degrees OddEvenRowPosition - every second row has the boards rotated by 180 degrees OddEvenRowsColumnsPosition - every second row and column has the boards rotated by 180 degrees
netRenamePattern - the pattern according to which the net names are transformed The default pattern is \"Board_{n}-{orig}\" which gives each board its own instance of its nets, i.e. GND becomes Board_0-GND for the first board , and Board_1-GND for the second board etc
refRenamePattern - the pattern according to which the reference designators are transformed The default pattern is \"Board_{n}-{orig}\" which gives each board its own instance of its reference designators, so R1 becomes Board_0-R1 for the first board, Board_1-R1 for the second board etc. To keep references the same as in the original, set this to \"{orig}\"
tolerance - if no sourceArea is specified, the distance by which the selection area for the board should extend outside the board edge. If you have any objects that are on or outside the board edge, make sure this is big enough to include them. Such objects often include zone outlines and connectors.
bakeText - substitute variables in text elements
Returns a list of the placed substrates. You can use these to generate tabs, frames, backbones, etc.
"},{"location":"panelization/python_api/#makelayersvisible","title":"makeLayersVisible","text":"makeLayersVisible(self)\nmakeMouseBites","text":"makeMouseBites(self, cuts, diameter, spacing, offset=250000, prolongation=500000)\nmakeRailsLr","text":"makeRailsLr(self, thickness, minWidth=0, maxWidth=None)\nmakeRailsTb","text":"makeRailsTb(self, thickness, minHeight=0, maxHeight=None)\nmakeTightFrame","text":"makeTightFrame(self, width, slotwidth, hspace, vspace, minWidth=0, minHeight=0, \n maxWidth=None, maxHeight=None)\nParameters:
width - width of substrate around board outlines
slotwidth - width of milled-out perimeter around board outline
hspace - horizontal space between board outline and substrate
vspace - vertical space between board outline and substrate
minWidth - if the panel doesn't meet this width, it is extended
minHeight - if the panel doesn't meet this height, it is extended
maxWidth - if the panel doesn't meet this width, TooLargeError is raised
maxHeight - if the panel doesn't meet this height, TooLargeHeight is raised
"},{"location":"panelization/python_api/#makevcuts","title":"makeVCuts","text":"makeVCuts(self, cuts, boundCurves=False, offset=0)\npanelBBox","text":"panelBBox(self)\npanelCorners","text":"panelCorners(self, horizontalOffset=0, verticalOffset=0)\nrenderBackbone","text":"renderBackbone(self, vthickness, hthickness, vcut, hcut, vskip=0, hskip=0, \n vfirst=0, hfirst=0)\nvcut, hcut specifies if vertical or horizontal backbones should be cut.
vskip and hskip specify how many backbones should be skipped before rendering one (i.e., skip 1 meand that every other backbone will be rendered)
vfirst and hfirst are indices of the first backbone to render. They are 1-indexed.
Return a list of cuts
"},{"location":"panelization/python_api/#save","title":"save","text":"save(self, reconstructArcs=False, refillAllZones=False)\nsetAuxiliaryOrigin","text":"setAuxiliaryOrigin(self, point)\nsetCopperLayers","text":"setCopperLayers(self, count)\nsetDesignSettings","text":"setDesignSettings(self, designSettings)\nsetGridOrigin","text":"setGridOrigin(self, point)\nsetPageSize","text":"setPageSize(self, size)\nsetProperties","text":"setProperties(self, properties)\nsetTitleBlock","text":"setTitleBlock(self, titleBlock)\nsetVCutClearance","text":"setVCutClearance(self, clearance)\nsetVCutLayer","text":"setVCutLayer(self, layer)\ntransferProjectSettings","text":"transferProjectSettings(self)\nAlso, transfers the list of net classes from the internal representation into the project file.
"},{"location":"panelization/python_api/#translate","title":"translate","text":"translate(self, vec)\nwriteCustomDrcRules","text":"writeCustomDrcRules(self)\nThis class represents a pice of substrate (with no components). Basically it is just a relatively thin wrapper around shapely polygons. On top of that, it keeps a partition line for the substrate. Read more about partition lines in understanding tabs.
"},{"location":"panelization/python_api/#backtosource","title":"backToSource","text":"backToSource(self, point)\nboundary","text":"boundary(self)\nboundingBox","text":"boundingBox(self)\nbounds","text":"bounds(self)\ncut","text":"cut(self, piece)\nexterior","text":"exterior(self)\nexteriorRing","text":"exteriorRing(self)\ninteriors","text":"interiors(self)\nisSinglePiece","text":"isSinglePiece(self)\nmidpoint","text":"midpoint(self)\nmillFillets","text":"millFillets(self, millRadius)\norient","text":"orient(self)\nremoveIslands","text":"removeIslands(self)\nserialize","text":"serialize(self, reconstructArcs=False)\ntab","text":"tab(self, origin, direction, width, partitionLine=None, maxHeight=50000000, \n fillet=0)\nWhen partitionLine is specified, the tab is extended to the opposite side - limited by the partition line. Note that if tab cannot span towards the partition line, then the tab is not created - it returns a tuple (None, None).
If a fillet is specified, it allows you to add fillet to the tab of specified radius.
Returns a pair tab and cut outline. Add the tab it via union - batch adding of geometry is more efficient.
"},{"location":"panelization/python_api/#translate_1","title":"translate","text":"translate(self, vec)\nunion","text":"union(self, other)\nThis document will show you how to use KiKit as a library for panelization. The full reference for the available API is located in the next section.
"},{"location":"panelization/scripting/#basic-concepts","title":"Basic concepts","text":"Let's start with an overview of the foundational concepts in KiKit.
"},{"location":"panelization/scripting/#units","title":"Units","text":"All units are in the internal KiCAD units (1 nm). You can use predefined constants to convert from/to them:
from kikit.units import *\n\nl = 1 * mm # 1 mm\nl = 42 * inch # 42 inches\nl = 15 * cm # 15 cm\na = 90 * deg # 90\u00b0\na = 1 * rad # 1 radian\nYou can also use functions fromMm(mm) and toMm(kiUnits) to convert to/from them if you like them more. You are also encouraged to use the functions and objects that the native KiCAD Python API offers, e.g.: pcbnew.wxPoint(args), pcbnew.wxPointMM(mmx, mmy), pcbnew.wxRect(args), pcbnew.wxRectMM(x, y, wx, wy).
When KiKit loads a KiCAD board, it takes the Edge.Cuts layer and tries to interpret it as a set of 2D polygons. If it cannot interpret them (i.e, there is a discontinuous outline), it raises an exception.
These polygons has a notion of what is inside and what is outside. We can also perform boolean operation on them (i.e., merge two polygons, subtract one from the other, etc.). When we save the panel, the polygons are converted back to outlines. All internal operations in KiKit that changes the board shape operate on top of the polygonal representation, not the outline themselves.
The polygonal representation of board shape is called PCB substrate and it is represented by the class kikit.substrate.Substrate. Internally, KiKit uses the library Shapely to represent the polygon. We advise you to get at least briefly familiar with it as whenever you need to create a new piece of substrate (e.g., for a tab) you will do so using the operations Shapely provides.
The Substrate class encapsulates the functionality regarding converting an outline into a polygon and vice-versa and modification of the substrate (add/subtract from it/construct a tab for it). For convenience, it also holds the partition lines associated with the substrate. For more details about partition lines, please refer to section Tabs below.
The panel construction is handled via kikit.panelize.Panel class. This class represents a panel under construction as pcbnew.Board without outlines. The outlines are represented via a substrate and it is converted into outline only on saving the panel to file.
The panel class provides you with a number of methods to construct the panel; e.g., append a board at given coordinates, create a grid of boards, add piece of substrate to it, add framing, create a cut, etc.
A typical workflow with the Panel class is the following:
appendBoard or makeAGrid),buildPartitionLineFromBB or manually set. Without a partition line the automatic tab building nor backbone do not work.During the whole process you can directly access panel.board of the type pcbnew.Board and use the KiCAD API to add or remove the features on the boards.
Every tab consists of two features: a piece of substrate that connects the individual board on the panel and a cut that will be broken when you depanelize the board.
In KiKit, the substrate is represented as a Substrate, more precisely as shapely.geometry.Polygon. This substrate is appended to the resulting panel substrate. The cut is represented as a polyline of the type shapely.geometry.LineString. KiKit accepts the polyline and it can either convert it into mouse bites or V-cuts.
You can build the tab substrate and cuts manually. In that case, just build the tab shape as Polygon and append it to the board via Panel.appendSubstrate. You also construct the cuts manually as LineString and you turn it
Panel.makeMouseBites, orPanel.makeVCuts. You can also use Panel.addVCutV or Panel.addVCutH in this case and avoid creating the LineString.You will use this approach in the simple cases or cases when you need a specially shaped tabs.
The second approach is to let KiKit generate the tabs and cuts automatically based on annotations. Annotation is just a marking on the board outline that specifies \"here should be a tab of this width\". You can read the annotations from source board (there are special footprints for that), generate it manually or use some of the strategies to place the annotations (e.g., place tabs in a spacing or in given number along edges). Note that the strategies often need a properly build partition line. Once you are finished, you can render the tabs using Panel.buildTabsFromAnnotations. This function will merge the tab bodies and returns a list of cuts. With the list of cuts, you can further decide whether to ignore them or render them via mousebites or V-cuts. For more details on the automated process of building tabs from annotations, see understanding tabs.
The document understanding tabs also explains what is a partition line and how it is used. Let us add that partition line is represented as shapely collection of line strings. The partition line is not a single one for the whole panel, but it is stored separately for each appended board as the annotations are rendered independently for each appended board.
Also note that you can use the partition line as guide when placing features (e.g., adding a holes on backbone, etc.).
"},{"location":"panelization/scripting/#appending-boards","title":"Appending Boards","text":"The simples approach to adding boards to a panel is using Panel.appendBoard. This places a board in the panel and also, it renames the nets such that they are panel-wise unique. This is necessary to pass DRC. You can specify the renaming pattern if you want. The substrate of the board is added the panel substrate, but it is also stored separately in Panel.substrates as the shape of the original board can be used to generate the automatic tabs and also it is used to copper-fill the non-board areas of the panel. You can also use these substrates to build your custom features.
If you make single-board panels, you can use the function Panel.makeGrid to quickly place the boards in a grid. The function returns the list of individual substrates. You can use the substrates e.g., to build custom tabs or other features.
When you place multiple PCB into the panel, KiKit expects you to generate a so-called partition line for each individual PCB. Partition line is an oriented (poly)line that partitions the free space between the PCBs. It gives you the information \"this part of the free space belongs to this PCB substrate and this PCB is responsible for placing tabs in that space\". So for a regular input the partition line can look like this:
For more complicated input, it can look like this:
Note several facts: - partition line is used for backbone generator - partition line is not generated automatically, it is up to the user to generate it. KiKit offers Panel.buildPartitionLineFromBB that builds the partition line based on bounding boxes. If you need possibly a more complicated lines, you have to implement them by yourself. - partition line is used for deciding if an annotation yields a tab or not - if the tab does not hit the partition line, it is not created. - when we create partition line from bounding boxes, we include \"ghost substrates\" representing the framing, that will be added in the future.
When KiKit generates a tab, it generates it based on tab origin, direction and optionally the partition line. When a tab is successfully generated, it consists out of two components - a piece of a substrate (which will be later appended to the panel) and a cut-line.
So assume we have the following PCB outline (the PCB is below the line, there is a free space above the line):
Then you specify your tab origin and its direction:
This is your input (e.g., via an annotation). Now KiKit does its job; it shoots two rays tabWidth apart and looks for the intersection with existing substrates. Note that if the ray starts within the PCB, no intersection will be found.
Once we have the intersections, we can easily generate the tab substrate and the cut:
Note that if we specify a partition line, than we shoot new rays in the opposite direction and try to hit the line. If we manage to do so, we get a tab. Otherwise, no tab is generated.
This is the basic algorithm for generating tabs. Well, we might also call them \"half tabs\". KiKit usually generates the half tabs around the board bounding box and then expects that two half tabs in the middle of the panel will merge into a single one. Also, KiKit first generates all the tabs and then merges them in one step to the board substrate. The cut is just a polyline which is in later steps either rendered as a V-cut or via mousebites.
"}]} \ No newline at end of file +{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"","title":"KiKit \u2013 Automation for KiCAD","text":"KiKit is a Python library, KiCAD plugin and a CLI tool to automate several tasks in a standard KiCAD workflow like:
Then definitely consider:
Your support will allow me to allocate time to properly maintain my projects like this.
PS: Be sure to check out my other KiCAD & PCB related projects:
Everything KiKit does, can also be done via Pcbnew in KiCAD. However, you have to do it manually. One of the common scenarios is the creation of panels. Most of the tutorials on the internet guide you to use the \"append board\" functionality of Pcbnew. However, this approach is labour-intensive, error-prone and whenever, you change the board, you have to do it again.
With KiKit you just call a CLI command if you have a simple layout (e.g., a grid) or write few Python instructions like \"place board here\", \"add bridge here\", \"separate boards via mouse bites/v-cuts\" and you are done. The process is repeatable and actually much simpler than hand-drawing the panels. KiKit also allows you to easily export all the Gerbers in a single step.
You can then write a Makefile and simply call make to get all your manufacturing data and board presentation pages.
Read the CLI documentation and the panelize documentation. Also don't miss the examples. There is also a quick not on how to use panelization action plugin. If you are interested in generating solder paste stencils, see Stencil documentation
"},{"location":"#acknowledgements","title":"Acknowledgements","text":"The project is supported by:
Please, first check FAQ. If you have not found answer for your problem there, feel free to open an issue on GitHub.
If you would like to have a feature in KiKit that is currently not on a roadmap, or if you need to prepare custom panelization script (e.g., multi-design panels, panels with specific arrangement), you can consider hiring me to do the job. Just reach out to me via e-mail and we can discuss further details.
"},{"location":"acknowledgements/","title":"Acknowledgements","text":"The project is supported by:
Thank you all!
"},{"location":"cli/","title":"KiKit CLI interface","text":"KiKit offers a simple CLI interface to perform common tasks easily. You can obtain help of the interface by calling kikit --help.
The interface is structured into nested commands. On the top level, there are the following commands available:
kikit export gerber <boardFile> [<outputDir>] - export gerber files of boardFile to outputDir. If no dir is specified, a new one <boardFile>-gerbers is created.kikit export dxf <boardFile> [<outputDir>] - export board outline and paste layers to DXF. The main use case for this command is making 3D printed solder paste stencils.Read more in a separate documentation section or see a walkthrough.
"},{"location":"cli/#separate-commands","title":"Separate commands","text":"Read more in a separate documentation section.
"},{"location":"cli/#stencil-commands","title":"Stencil commands","text":"Read more in a separate documentation section.
"},{"location":"cli/#present-commands","title":"Present commands","text":"kikit present boardpage --name <pagename> -d <descriptionFile> -b <name comment boadfile> -r <resource> --template <template> --repository <url> <outputdir> - generate single webpage providing board preview and a possibility to download board files (gerbers and sources). See an example of such page.-r or --resource. Resources are files which will be copied to the output directory. Useful for images referred from description-b or --boarddefault). See template documentation for more information about templates.kikit modify references --show/--hide --pattern <pattern> <board> hide or show all references on the board matching a regular pattern.
kikit modify values --show/--hide --pattern <pattern> <board> is the same as above, just with footprint values.
KiKit respects the KiCAD component selection criteria. When you specify an input rectangle, only the components that fully fit inside the input rectangle are selected. This however take in account both name and value labels.
When you do not specify the source are explicitly, KiKit takes the board outline bounding box as the source area. Therefore, by default, components outside the board substrate are not copied to panel.
Since version 1.1 this behavior, however, changes for footprints. KiKit decides whether to keep a footprint or not based on whether its origin fits inside the source area or not. For graphical items, the behavior remains the same. The reason for this change is that often footprints reach out beyond the board edge (e.g., connectors) and the users don't want to remove them. On the other hand, graphical items (e.g., texts or arrows towards the board) are purely for documentation purposes and thus, they shouldn't be included in the panelized design.
Note that this is intended behavior; for once it is consistent with KiCAD behavior of user selection and also it allows to easily ignore surrounding comments and drawings in the board sheet (it makes no sense to have 12 same copies of the notes around the board).
How to include the components? - specify the source area explicitly to include all your components - specify tolerance: 20mm for source (i.e., --source 'tolerance: 20mm') to enlarge the board outline bounding box. The default value is 1 mm.
KiKit's millradius parameter from the postprocess section simulates the board outline milling by a tool with given radius. That means that it will round all inner corners. It is not a command to round just your tabs. That means if you specify a tool which diameter is larger than your slot, KiKit will remove the slot as such slot cannot be created with the tool.
This is an intended behavior. The options is designed for you to check if your board can be manufactured with all the features you have in your board outline. There aren't many fabrication houses that support sharp inner corners as they cannot be milled but have to be e.g., broached, which is much more complicated and expensive setup.
If you want to preserve your narrow internal slots: - don't specify millradius at all in the postprocess - specify smaller millradius but make sure that your fabrication house supports such small tools.
KiKit's mouse bites offset specifies how much should be the mouse bites put inside the board. The recommended value is 0.25 mm (read about it in this blog post). Why is it so? When you break the tab, there will be rough edges. By putting the mouse bites inside the board, these rough edges won't be sticking outside the designed board outline. When you want to fit your board in a tight enclosure, you don't have to perform manual deburing. Since it is considered a good practice, KiKit makes this the positive direction so you don't have to put minus everywhere.
If you don't want to put mouse bites inside your board, just specify zero or negative offset.
"},{"location":"faq/#i-have-board-with-no-spacing-but-some-v-cuts-are-missing","title":"I have board with no spacing, but some V-cuts are missing.","text":"The default style of tabs (spacing) does not generate in such a case any tabs, and, therefore, not cuts. Please use tab style full.
ModuleNotFoundError: No module named 'pcbnew'","text":"You probably installed KiKit via Windows command prompt, not KiCAD Command Prompt.
"},{"location":"faq/#i-would-like-to-make-a-panel-out-of-different-designs-but-there-is-no-such-option-in-help","title":"I would like to make a panel out of different designs, but there is no such option in help","text":"KiKit supports such feature. But it is not available from CLI. You have to write a simple Python script describing the panel and use KiKit as a library. Also, please refer to the panelization documentation.
If you wonder why is it in such way: there are infinitely many ways to panel your design. A single CLI/UI will not fit them all and also even for the simple cases, it would be enormous and painful to use. Much better idea is to use a language to specify the panel. But why reinvent the wheel and design a custom language when we can use Python? It integrates well with other tools and many people already know it.
"},{"location":"faq/#there-are-no-plugins-in-kicad","title":"There are no plugins in KiCAD!","text":"You have to install them via KiCAD PCM. See the installation guide.
"},{"location":"faq/#how-do-i-run-kikit-with-kicad-nightly","title":"How do I run KiKit with KiCAD nightly?","text":"See section \"Choosing KiCAD version\" in the installation guide. However, at the moment KiKit is incompatible with KiCAD 6.99.
"},{"location":"multiboard/","title":"Multiboard workflow","text":""},{"location":"multiboard/#multi-board-workflow-with-kikit","title":"Multi-board workflow with KiKit","text":"KiCAD does not support multiple board per project, nor boards with shared schematics. However, with the following workflow, you can easily draw multiple boards with shared schematics and, e.g., easily ensure that tha board connectors match.
The workflow is the following:
First, draw a separate schematics sheet for each of your boards and propagate the pins on the inter-board connectors. E.g., in one of my project it looks like this:
I also place the corresponding connectors next to each other to illustrate that they connect. Then draw your board schematics as usual - with one exception. Do not use global power symbols nor global labels, use only local labels. This ensures that the power lines are separate for each board and DRC won't complain, that you have not connected the power between two board.
Then, draw all your boards into a single board file side-by-side. See file resources/multiboard.kicad_pcb for a dead simple illustration. You can also draw lines that will help you align your boards' connectors.
Before manufacturing, use KiKit to extract the boards into a separate board files via the extract command.
This can be done in two ways:
We will show how to use it on resources/multiboard.kicad_pcb which looks like this:
"},{"location":"multiboard/#bounding-box-selection","title":"Bounding box selection","text":"Simply specify the top left and bottom right corner. Everything that fits fully inside it, will be included in the board. The command for separation of board A into a separate board file is:
kikit separate --source 'rectangle; tlx: 89mm; tly: 89mm; brx: 111mm; bry: 111mm' \\\n multiboard.kicad_pcb board_a.kicad_pcb\nAfter that, board_a.kicad_pcb will contain only a board A. Note that the \\ is there for shell as we split our command into two lines.
As you can see, the source file contains an annotation in the form of virtual footprints kikit:Board. You can place them into your document so that the arrow points to the board edge. Than you can use the reference of the annotation symbol for separation of the board. To separate board A simply invoke:
kikit separate --source 'annotation; ref: B1' \\\n multiboard.kicad_pcb board_a.kicad_pcb\nAfter that, board_a.kicad_pcb will contain only a board A. Note that the \\ is there for shell as we split our command into two lines.
Note that if panelize your boards, you don't have to separate your boards first; just use the --source with the panelization command.
When you use the separate command, KiKit preserves all annotations within the source bounding box. If you would like to strip the annotations, you can specify --stripAnnotation and KiKit will remove all annotations from the resulting board.
Present is a collection of functions providing various ways to present KiCAD boards. The main one is a simple page generator which can be used in continuous integration to build pages where your users and collagues can download the automatically generated panels.
"},{"location":"present/#requirements","title":"Requirements","text":"In order to include PCB drawings in presentations you will need to install PcbDraw.
"},{"location":"present/#template-namepath-resolution","title":"Template name/path resolution","text":"The template argument is either a name of a built-it template or a path to a directory with a user-defined template. During the name resolution the first test is for the user-defined template; i.e., check if the name provided by the user is a directory path and the directory contains the file template.json. If not, try to resolve the name as the name of the built-in template.
A template is a directory containing template files. There is a single mandatory file common to all template types template.json. An example of such file follows:
{\n \"type\": \"HtmlTemplate\",\n \"resources\": [\"css/*.css\"]\n}\nThe key type specifies what kind of template it is. Currently, only HtmlTemplate is supported (see more info about them below). Then there is the list of resources which are glob patterns for resource files which are copied to the output directory when rendering the template.
Expects an index.html file in the root of the template. This is Handlerbars template which receives the following dictionary on render:
\"repo\": self.repository,\n\"gitRev\": gitRev,\n\"gitRevShort\": gitRev[:7] if gitRev else None,\n\"datetime\": self.currentDateTime(),\n\"name\": self.name,\n\"boards\": self.boards,\n\"description\": self.description\nboards is a list of a dictionary with following keys:
front path to render of the front sideback path to render of the back sidegerbers path to archive with gerbersfile path to kicad_pcb fileSee the default template in kikit/resources/present/templates/default for a starting point for custom templates.
If you populate your boards using a reflow oven, you often need solder paste stencils. One of the inconveniences with stencils is that you have to align them manually. It is not hard, but it takes some time and a little bit of practice & tricks (e.g. to use other PCBs for stencil alignment).
KiKit provides two ways to generate stencils:
KiKit allows you to ignore components from the stencil by specifying --ignore followed by a comma separated list of components' references to exclude. Pads of these components will not appear in the stencil. This is useful, when you do not want to populate all components.
The second common option is --cutout followed by a comma separated lists of components' references. For these components, the stencil will contain a cutout based on the component courtyard. This is useful when you have already pre-populated board and you want to populate more components -- e.g., when your assembly house does not have a special IC and you populate it yourself and also, when you do a board repair.
I wrote a blog post about the 3D printed self-registering stencils on my blog. These stencils are quick solution when you urgently need a stencil but probably they don't last long and might come with imperfections.
To generate such stencil, just call:
kikit stencil createprinted [parameters] <boardFile> <outputDirectory>\n--pcbthickness FLOAT PCB thickness in mm\n--thickness FLOAT Stencil thickness in mm. Defines amount of paste\n dispensed\n--framewidth FLOAT Register frame width\n--ignore TEXT Comma separated list of components references to\n exclude from the stencil\n--frameclearance FLOAT Clearance for the stencil register in milimeters\n--enlargeholes FLOAT Enlarge pad holes by x mm\nKiKit will output two STL files representing bottom and top register to the specified directory. You can directly print these files. In theory, if you don't have small pads spacing, you could print them even on FDM machine, but I haven't tested it.
"},{"location":"stencil/#steel-stencils","title":"Steel Stencils","text":"Many fabhouses offer you to create a custom stencil. However, it is pain to align them. Therefore, KiKit offers a functionality to automatically generate stencils which fit a simple 3D printed or lasercut alignment jig.
The jig is available as Fusion 360 model, STEP or 3MF.It it designed to be cut from 3mm thick acrylic but you can also print it. You need 4 2mm pins, 8 M2 screws and that's it. The frame can be customized - there two parameters of the model, frameWidth and frameHeight which define the largest PCB it can accept. I usually use 100x100mm and 60x60mm.
Then you issue the following command within KiKit:
kikit stencil create --jigsize 60 60 <boardFile> <outputDir>\nkikit stencil create --help. KiKit will produce 2 STL files for aligning the PCB and a zip file with gerbers for the manufacturer. When you order your stencil, let them make both top and bottom side on the same stencil. One tip for JLC PCB: set custom size of the stencil when you order it - then it fits into your package with your PCB and you don't have to pay for extra shipping.
The stencil you receive should look like on the following picture. It has mouse bites so you can easily break it off to precise size. It also has mounting holes.
Once you break the stencils off, you mount them in the jig frame:
Then you print alignment parts for your board and mount in onto the jig using M2 screws:
Then you just use 2mm pins to align the frame and you can apply the paste!
The acrylic jig is reusable - you just have to mount new alignment pieces and change the stencil.
"},{"location":"fabrication/intro/","title":"Fabrication","text":"KiKit offers fully automatic export of all data required for fabrication of your designs. Since every fabrication house has different requirements on the design files (e.g., special names of gerber files, different requirements for assembly files) there is no \"universal exporter\" in KiKit. Instead, KiKit offers special command for each supported fabrication house.
"},{"location":"fabrication/intro/#common-options","title":"Common Options","text":"All fab subcommands has a common invocation structure:
kikit fab <fabhouse> <options> <sourceDir> <outputDir>\nAll commands also support the following options:
--drc\\--no-drc (default --drc). Check for DRC violations before exporting the files. With this options, you won't send a board that fails DRC to your manufacturer.--nametemplate <str>: If you want to name your files differently, specify this option. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically. Variables in text are also supported eg: {boardTitle}_rev{boardRevision}_{date}_{}. The project variables are available with the user- prefix; e.g., `MFR: {user-mfr}```Each of the fab command also take additional, manufacturer specific, options. See documentation for the individual manufacturer below:
"},{"location":"fabrication/intro/#currently-supported","title":"Currently Supported:","text":"Note: click on the name of the manufacturer to see corresponding documentation:
To add a new fabrication command you have to extend KiKit's source code. A rather basic knowledge of python is required to do so.
Create a new file kikit/fab/fabhousename.py and implement a new command with the same name as the file. Then add the command to kikit/fab/__init__.py. The common functionality for all fabrication houses should be located in kikit/fab/common.py. You can use kikit/fab/jlcpcb.py for inspiration.
Once you implement a support for new fabrication house, open a pull request on KiKit's GitHub page.
"},{"location":"fabrication/jlcpcb/","title":"Fabrication: JLC PCB","text":"The basic usage of this exporter is:
kikit fab jlcpcb [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file gerbers.zip in OUTPUTDIR. This file can be directly uploaded to JLC PCB site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically.
If you would also like to use the SMD assembly service, you have to specify --assembly option and also provide the board --schematic <schematics_file>. KiKit will generate two extra files: bom.csv (bill of materials) and pos.csv (component placement). Use these two files when ordering the PCB assembly.
The files above will include all components on the board. You can override the default field name with option --field. This option accepts a comma separated list of names. The first found field is used. This can be used, e.g., for configuration of the board via resistors. You can put field \"LCSC\" for all components, then add fields \"CFG1_LCSC\" and \"CFG2_LCSC\" for some components. Then invoke KiKit with option --field CFG1_LCSC,LCSC for configuration 1 or --field CFG2_LCSC,LCSC for configuration 2.
You can exclude some of the components by specifying --ignore <comma separated list of references>. You can also specify component field with name JLCPCB_IGNORE (the value of the field does not matter) to exclude the component from assembly. Also, if a component misses the order code field, KiKit will show warning. When you pass option --missingError, KiKit will fail when there is a component with missing order code. This might be useful in case when you run KiKit in CI and you want to fail the build.
Note that when you order SMD assembly for a panel, you should specify panelized board and the original schematics of a single board.
"},{"location":"fabrication/jlcpcb/#correction-of-the-footprint-position","title":"Correction of the Footprint Position","text":"It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by JLCPCB_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
If your board features solder jumpers you can use the corrections to specify their default value. The solder jumper should be designed such it can fit a zero Ohm resistor in suitable size. Then specify an order code of the zero Ohm resistor for the jumper and adjust correction so it fits the default position.
Note that you can specify multiple correction fields by --corrections <comma separated list of correction filed names>. The first found correction field is used. This allows you to keep several configuration of the solder jumpers in your design e.g., in fields JLCPCB_CORRECTION_CFG_1 and JLCPCB_CORRECTION_CFG_2. Then you can simply change the board configuration by calling kikit with --corrections JLCPCB_CORRECTION_CFG_1,JLCPCB_CORRECTION or --corrections JLCPCB_CORRECTION_CFG_2,JLCPCB_CORRECTION.
The basic usage of this exporter is:
kikit fab neodenyy1 [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file top_pos.csv and bottom_pos.csv in OUTPUTDIR. This file can be used in Neoden YY1. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. This option takes a string that should contain {}. This string will be replaced by gerber, pos or bom in the out file names. The extension is appended automatically.
For Neoden YY1 you must specify --assembly option and provide the board --schematic <schematics_file>. KiKit will generate files: top_pos.csv (top layer component placement) and bottom_pos.csv (bottom layer component placement). Use these two files to assembly PCB on machine.
On Neoden YY1, the position origin must use the bottom left corner of the board edge.
"},{"location":"fabrication/neodenyy1/#correction-of-the-footprint-position","title":"Correction of the Footprint Position","text":"It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by YY1_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
The basic usage of this exporter is:
kikit fab openpn [OPTIONS] BOARD OUTPUTDIR\nThis exporter creates a single file components.pos that mimics KiCAD native .pos output. However, unlike KiCAD, it adds a unique identifier to component references to ensure they are unique (in the case of panels).
The basic usage of this exporter is:
kikit fab oshpark [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find gerbers.zip in OUTPUTDIR. This file can be directly uploaded to the OSH Park site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. The extension is appended automatically.
The basic usage of this exporter is:
kikit fab pcbway [OPTIONS] BOARD OUTPUTDIR\nWhen you run this command, you will find file gerbers.zip in OUTPUTDIR. This file can be directly uploaded to the PCBWay site. KiKit automatically detects the number of layers.
If you want to name your files differently, you can specify --nametemplate. For detailed description of this option, see JLC PCB documentation.
If you would also like to use the SMD assembly service, you have to specify --assembly option and also provide the board --schematic <schematics_file>. KiKit will generate two extra files: bom.csv (bill of materials) and pos.csv (component placement). Use these two files when ordering the PCB assembly.
The files above will include all components on the board by default, except footprints having the attribute virtual set. You should provide the \"Manufacturer\" and \"PartNumber\" Fields for each component, where PartNumber refers to the manufacturers part number (and can safely contain non-digit characters). If the \"Description\" field is present, this value will be inserted in the \"Value/Description\" column in the BOM, otherwise the value of the component. It is recommended to provide no description for capacitors, resistors, and inductors, so that the value is inserted into the BOM for them. PCBWay also requires the soldering type (SMD, thru-hole, ...) to be specified. Any footprint only having SMD pads will be considered as \"SMD\", everything else as \"thru-hole\". You can manually overwrite the type by adding a \"Type\" field to the component. For the footprint column of the BOM the KiCad footprint name is used by default. Add a \"FootprintPCBWay\" field to overwrite this in the BOM list for a more human readable footprint name, if you want. Finally, notes or assembly instructions can be added using the \"Notes\" field.
You can exclude some of the components by specifying --ignore <comma separated list of references>. When you pass option --missingError, KiKit will fail when there is a component with missing manufacturer and/or part number. This might be useful in case when you run KiKit in CI and you want to fail the build.
Note that when you order assembly for a panel, you should specify panelized board and the original schematics of a single board. Use the --nBoards parameter to specify the number of boards in the panel. The quantity column is generated by multiplying this number with the number of references in each row.
It is possible that orientation footprints in your SMD does not match the orientation of the components in the SMD assembly service. There are two solutions:
The first option is not always feasible - e.g., when you use KiCAD's built-in libraries or you are preparing a board for multiple fabrication houses and each of them uses a different orientation.
KiKit allows you to specify the origin and orientation correction of the position. The correction is specified by PCBWAY_CORRECTION field. The field value is a semicolon separated tuple: <X>; <Y>; <Rotation> with values in millimeters and degrees. You can read the XY corrections by hovering cursor over the intended origin in footprint editor and mark the coordinates. Note that first the rotation correction is applied, then the translation. Usually, you will need only the rotation correction.
If your board features solder jumpers you can use the corrections to specify their default value. The solder jumper should be designed such it can fit a zero Ohm resistor in suitable size. Then specify an order code of the zero Ohm resistor for the jumper and adjust correction so it fits the default position.
Note that you can specify multiple correction fields by --corrections <comma separated list of correction filed names>. The first found correction field is used. This allows you to keep several configuration of the solder jumpers in your design e.g., in fields PCBWAY_CORRECTION_CFG_1 and PCBWAY_CORRECTION_CFG_2. Then you can simply change the board configuration by calling kikit with --corrections PCBWAY_CORRECTION_CFG_1,PCBWAY_CORRECTION or --corrections PCBWAY_CORRECTION_CFG_2,PCBWAY_CORRECTION.
When you have multiple versions of KiCAD installed, it might be desirable to run KiKit with one or another (e.g., to not convert your designs into new format).
KiKit loads the Python API directly via a module, so which module is loaded (which KiCAD version is used) follows standard Python conventions. Therefore, to choose a particular KiCAD version, just specify the environmental variable PYTHONPATH. The path have to point to a folder containing the module (pcbnew.py file).
The most common on linux are:
stable: /usr/lib/python3/dist-packages/pcbn\nnightly: /usr/lib/kicad-nightly/lib/python3/dist-packages/\nE.g., to run KiKit with nightly, run:
PYTHONPATH=/usr/lib/kicad-nightly/lib/python3/dist-packages/ kikit\nTo run KiKit with a KiCAD you compiled (and not installed):
PYTHONPATH=path-to-sources/build/pcbnew kikit\nThis also works when you invoke make as environmental variables are propagated:
PYTHONPATH=/usr/lib/kicad-nightly/lib/python3/dist-packages/ make\nThis method is applicable to Windows, Linux and MacOS. It provides access to all of the CLI commands in a known-working container, but doesn't allow your local install of KiCad to access KiKit via the KiKit plugin.
First, install Docker. The installation procedure varies by the platform, so Google up a recent guide for your platform.
With Docker you can skip all of the install steps and instead run KiKit via (on Linux or Mac):
docker run -v $(pwd):/kikit yaqwsx/kikit --help\n--help with whatever command you want to run. Try --version or panelize) or on Windows:
docker run -v %cd%:/kikit yaqwsx/kikit --help\nNote that on Windows you might have to explicitly allow for mounting directories outside your user account (see the following topic).
"},{"location":"installation/docker/#creating-an-alias-to-kikit-in-docker-to-save-some-typing","title":"Creating an alias to KiKit in Docker to save some typing","text":"If you're on Linux or Mac and are going to run commands repeatedly within the same directory you can create an alias within the current terminal session via:
alias kikit=\"docker run -v $(pwd):/kikit yaqwsx/kikit\"\nalias is a Linux/ Unix command so won't work on Windows, you'll need to call docker run -v %cd%:/kikit yaqwsx/kikit each time. Also note that you must update the alias (by running the same alias command again) if you move to a different directory. The current working directory for the alias is \"frozen\" at the directory you create the alias in. From then on, until you close that terminal, you'll be able to just run kikit followed by the relevant paramenters (e.g. kikit --version or kikit panelize).
If you would like to run a particular version of KiKit, simply append a tag to the image name (e.g., yaqwsx/kikit:nightly), and Docker will pull that version down and run that for you instead:
docker run -v $(pwd):/kikit yaqwsx/kikit:nightly --version\nWe provide the following containers:
A full list is available on Dockerhub.
"},{"location":"installation/docker/#mac-m1-containers","title":"Mac M1 containers","text":"There are also nightly containers of Mac M1 available with tag nightly-m1.
If you want to use Makefile for your projects, the preferable way is to invoke make inside the container. The Docker image contains several often used tools and you can even run KiCAD from it (if you supply it with X-server). To call make within the container, override the container's entrypoint:
docker run -it -v $(pwd):/kikit --entrypoint '/usr/bin/make' --help\n--help with your make command, such as build or test)."},{"location":"installation/gui_and_libs/","title":"GUI and libs installation","text":""},{"location":"installation/gui_and_libs/#kikit-symbol-and-footprint-libraries","title":"KiKit Symbol and Footprint Libraries","text":"From v6 onwards KiCad comes with a \"Plugin and Content Manager\" (PCM) which can be used to add the KiKit symbol and footprint libraries used in multi-board workflows. The PCM is new functionality for KiCad though, and only does part of the installation in v6. To install the libraries using the PCM:
Tools menu and select Plugin and Content ManagerLibraries tab and scroll down to KiKit LibraryInstall and then Apply ChangesThe following steps are only required in KiCad 6, they are automated in KiCad 7:
Preferences menu and select Manage Symbol LibrariesGlobal Libraries tab, and click the + icon towards the bottom of the window then enter kikit (all lowercase) as the nickname, and ${KICAD6_3RD_PARTY}/symbols/com_github_yaqwsx_kikit-library/kikit.kicad_sym as the Library Path.OKPreferences menu and select Manage Footprint LibrariesGlobal Libraries tab, with a nickname kikit (all lowercase again), and this time enter ${KICAD6_3RD_PARTY}/footprints/com_github_yaqwsx_kikit-library/kikit.pretty for the Library Path.OKkikit alongside all the others.KiKit consists of three parts:
Unfortunately, it is not possible to install all three parts automatically in a single step due to technical limitations of KiCAD's PCM at the moment, so you have to install them separately.
"},{"location":"installation/intro/#backend-installation","title":"Backend installation","text":"The backend installation differs slightly based on the platform:
GUI plugins and libraries are available via KiCAD PCM. See details about their installation.
"},{"location":"installation/intro/#optional-dependencies","title":"Optional dependencies","text":"Some KiKit features rely on external dependencies:
We also distribute a Docker container for running KiKit in CI or on platform where it is hard to meet all dependencies. This mode doesn't support GUI. Learn more about the docker images.
"},{"location":"installation/linux/","title":"Installation on Linux","text":"KiKit is distributed as PyPi package.
"},{"location":"installation/linux/#instalation-for-kicad-installed-via-system-package-manager","title":"Instalation for KiCAD installed via system package manager","text":"The installation consists of a single command you have to enter into the terminal. If you installed KiCAD via package manager (apt, yum, etc.) you can use a regular terminal and enter pip3 install kikit. Now you are ready to use KiKit.
However, if you installed KiCAD via Flatpak, you have to open a special terminal as Flatpak sandboxes the applications. Open terminal and invoke flatpak run --command=sh org.kicad.KiCad, this will open a terminal session inside the KiCAD\u2019s sandbox. Now you can install pip via python3 -m ensurepip and then, inside the same terminal you can install KiKit: python3 -m pip install kikit. If you would like to use CLI interface, all commands have to be invoked inside the shell flatpak run --command=sh org.kicad.KiCad, and, instead of kikit something you have to use python -m kikit.ui something.
Now you can test that it works:
> kikit --help\nYou should get something like this:
Usage: kikit [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nNow you are done with the basic installation. If you plan to use graphical interface, install GUI frontend and libraries via PCM.
"},{"location":"installation/macos/","title":"KiKit Installation on MacOS","text":"Installation on MacOS is a little more involved as MacOS enforces that all external programs are signed. KiCAD installed via homebrew is signed, however, once plugins with binary dependencies are installed, the signature gets invalidated. This prevents KiKit from running.
The current solution is to re-sign KiCAD after KiKit installation. Therefore, KiKit's installation on MacOS is twofold: - create a self-signed certificate - install KiKit and sign KiCAD
"},{"location":"installation/macos/#create-a-codesigning-certificate","title":"Create a codesigning certificate","text":"Open Keychain a select \"Create a Certificate\":
Then, enter name \"kikit\", select \"Self-Signed Root\" and type \"Code Signing\":
Confirm and the certificate is ready.
"},{"location":"installation/macos/#install-kikit-related-wrappers","title":"Install KiKit & related wrappers","text":"We provide a script for KiKit installation's, KiCAD signing and creating a wrapper script for KiKit. You can find the script here. You can download and run it. Open a terminal and enter:
$ curl -O https://raw.githubusercontent.com/yaqwsx/KiKit/master/scripts/installMacOS.bash\n$ sudo bash installMacOS.bash\nThe script will ask you for a password several times. Once it finishes, you can test it:
$ kikit --help\nUsage: python3 -m kikit.ui [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nOnce you install the PCM plugin, KiKit will be available via GUI in Pcbnew.
"},{"location":"installation/upgrading/","title":"Upgrading KiKit and installing special versions","text":""},{"location":"installation/upgrading/#upgrading-kikit","title":"Upgrading KiKit","text":"If you want to upgrade KiKit, you have to perform two steps:
pip install -U kikit in the command line (depending on the platform, see the installation instructions for individual platform).If you would like to install a specific version of KiKit (e.g., the upstream version), you can install it directly from git. The command for that is:
# The master branch (also called the upstream version) - the most up-to-date KiKit there is (but might me unstable)\npip install git+https://github.com/yaqwsx/KiKit@master\n# A concrete branch, e.g., from a pull request\npip3 install git+https://github.com/yaqwsx/KiKit@someBranchName\nTo install KiKit on Windows, you have to open \"KiCAD Command Prompt\". You can find it in the start menu:
Once you have it open like this:
you can put command in there and confirm them by pressing enter. This is also the prompt from which you will invoke all KiKit's CLI commands. They, unfortunately, does not work in an ordinary Command prompt due to the way KiCAD is packaged on Windows.
Then you have to enter the following command to install it:
pip install kikit\nNow you can test that it works:
kikit --help\nYou should get something like this:
Usage: kikit [OPTIONS] COMMAND [ARGS]...\n\nOptions:\n --version Show the version and exit.\n --help Show this message and exit.\n\nCommands:\n drc Validate design rules of the board\n export Export KiCAD boards\n fab Export complete manufacturing data for given fabrication houses\n modify Modify board items\n panelize Panelize boards\n present Prepare board presentation\n separate Separate a single board out of a multi-board design.\n stencil Create solder paste stencils\nNow you are done with the basic installation. Don't forget to get the GUI frontend and libraries via PCM.
"},{"location":"panelization/cli/","title":"Panelization CLI","text":"The whole panelization process of KiKit's CLI is driven by a configuration structure. The configuration contains several categories (e.g., layout, tabs, framing). Each of the categories have number of named parameters (e.g., tabsCount). All categories and their parameters are described further below.
Note that you can use the pcbnew action plugin to interactively construct the panelization configuration structure.
"},{"location":"panelization/cli/#configurations","title":"Configurations","text":"The configuration can be supplied to KiKit via a JSON file with comments and from the command line. The example of a configuration in a JSON file is the following
{\n // There can be C-like comments\n \"layout\": {\n \"type\": \"grid\",\n \"rows\": 1,\n \"cols\": 1,\n \"hspace\": \"0mm\",\n \"vspace\": \"0mm\",\n \"rotation\": \"0deg\",\n \"alternation\": \"none\",\n \"renamenet\": \"Board_{n}-{orig}\",\n \"renameref\": \"{orig}\"\n },\n \"source\": {\n \"type\": \"auto\",\n \"tolerance\": \"1mm\"\n },\n \"tabs\": {\n \"type\": \"normal\",\n \"source\": \"none\"\n },\n \"cuts\": {\n \"type\": \"none\"\n },\n \"framing\": {\n \"type\": \"none\",\n \"thickness\": \"0mm\",\n },\n \"post\": {\n \"type\": \"auto\",\n \"millradius\": \"0mm\",\n \"copperfill\": false\n }\n}\nKiKit accepts -p <configurationFile> option to specify one or more configurations. When multiple configurations are specified, they are composed into a single configuration. The later specified configurations overwrite parameters of the former specified configurations. This allows us to start with a basic configuration and have a number of small configurations specifying details.
To give and example, consider the two following configurations:
// A\n{\n \"tabs\": {\n \"type\": \"normal\",\n \"width\": \"3mm\"\n },\n \"framing\": {\n \"type\": \"frame\"\n }\n}\n\n// B\n{\n \"framing\": {\n \"type\": \"rails\"\n \"width\": \"5mm\"\n }\n}\nWhen we merge B into A, we get:
{\n \"tabs\": {\n \"type\": \"normal\",\n \"width\": \"3mm\"\n },\n \"framing\": {\n \"type\": \"rails\"\n \"width\": \"5mm\"\n }\n}\nYou can also override every parameter from CLI. There is an option for each category, which accepts a semicolon-separated list of key-value pairs; e.g.:
--layout 'rows: 3; cols: 4'\nThe options from CLI have the highest priority - they override values from specified from the files. If you need to specify the character ;, you can escape it via \\.
Therefore, a full invocation of KiKit for panelization can look like this:
kikit panelize -p myDefault.json -p useVcuts.json -p myFrame.json\n --layout 'rows: 3; cols: 4'\n board.kicad_pcb panel.kicad_pcb.\nNote the single quotes -- without them your shell will eat the spaces and the command will be interpreted badly. The command will use our default configuration, then it will override some options to use V-cuts and then it adds a frame specified by myFrame.json. Last we specify the panel size from CLI.
Note that KiKit always start with a default configuration (specified in the file default.json). There are also some configuration files shipped with KiKit. You can find them in the directory kikit/resources/panelizePresets. When you want to use them via option -p, just prefix their name with : and drop the suffix. E.g., for vcuts.json use -p :vcuts.
If you would like to inspect which configuration was used by KiKit, you can dump it into a file with the -d <filename> option.
You can specify units in the configuration files and CLI. Always specify them as string, e.g., \"2mm\" or \"0.5 inch\" (do not forget the quotes in the JSON files).
Supported length units: mm, cm, dm, m, mil, inch, in.
Supported angle units: deg, \u00b0, rad.
"},{"location":"panelization/cli/#configuration-categories","title":"Configuration categories","text":"There are the following categories: layout, source, tabs, cuts, framing, and tooling.
Each category has a mandatory parameter type which dictates the style of that feature. Note that you can specify the type parameter in a simplified manner in the CLI by specifying it first and omitting the type word; e.g., --cuts 'mousebites, someParameter: 10cm'.
Types: grid, plugin
Common options:
hspace, vspace, space: Specify the gap between the boards. You can specify separately vertical and horizontal spacing or you can specify space to make them the same (it has higher priority).rotation: Rotate the boards before placing them in the panelrenamenet, renameref: A pattern by which to rename the nets and references. You can use {n} and {orig} to get the board number and original name. Default values are Board_{n}-{orig} for nets and {orig} for references.baketext: A flag that indicates if text variables should be substituted or not.The boars are placed in a grid pattern connected by tabs. There are no special options.
rows, cols: Specify the number of boards in the grid patternalternation: Specify alternations of board rotation.none: Do not alternaterows: Rotate boards by 180\u00b0 on every next rowcols: Rotate boards by 180\u00b0 on every next columnrowsCols: Rotate boards by 180\u00b0 based on a chessboard patternvbackbone, hbackbone: The width of vertical and horizontal backbone (0 means no backbone). The backbone does not increase the spacing of the boards.vboneskip, hboneskip: Skip every n backbones. I.e., 1 means place only every other backbone.vbonefirst, hbonefirst: Specify first backbone to render. Allows to specify the offset when skipping backbones. The offset is indexed from 1.vbonecut, hbonecut: true/false. If there are both backbones specified, specifies if there should be a vertical or horizontal cut (or both) where the backbones cross.Implements a custom layout based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginThis option allows you to specify the source area, e.g., when multiple boards are present. You can read more about multi-board project here.
Types: auto, rectangle, annotation
Common options:
stack: specify the number of layers of the panel. Valid options are 2layer, 4layer, 6layer or inehrit (default). The use case for this option is when you design a multiple boards in a single desing and you separate them, however, one boards is e.g., 4 layer and one 2 layer. Then you design both of them as 4 layer and you specify stack: 2layer for the 2 layer one when panelizing or separating.Find all board edges and use them to construct source rectangle. Suitable for most cases when there is only a single board in the design. Note that might want to increase tolerance or specify the source area explicitly via rectangle if you have components sticking out of your design.
tolerance: KiKit extracts only board items that fit fully into the source area (including all drawings on all layers). Tolerance enlarges the source area by given amount, to e.g., not omit KiKit annotations for tabs or connectors sticking out of the board.Specify the source rectangle explicitly.
tlx, tly, brx, bry: specify the coordinates (via length units) of the rectangle via top-left and bottom-right corner.KiKit offers you to place an annotation footprint kikit:Board into your design file to name the board. The area is determined by a bounding box of the lines in the Edge.Cuts layer that the arrows point to. Note that the tip of the arrow must lie on the PCB edge or slightly outside of it.
ref: specify the annotation symbol referencetolerance: see aboveTypes: fixed, spacing, full, annotation, plugin
Place tabs. To make some of the options clear, please see the explanation of tab placement process.
"},{"location":"panelization/cli/#fixed","title":"Fixed","text":"Place given number of tabs on the PCB edge. The tabs are spaced uniformly. If you need a custom tab placement (e.g., to avoid critical feature), see type annotation.
vwidth, hwidth, width: The width of tabs in the vertical and horizontal direction. width overrides both.vcount, hcount: Number of tabs in a given direction.mindistance: Minimal spacing between the tabs. If there are too many tabs, their count is reduced.Place tabs on the PCB edges based on spacing.
vwidth, hwidth, width: The width of tabs in the vertical and horizontal direction. width overrides both.spacing: The maximum spacing of the tabs.Create tabs that are full width of the PCB. Suitable for PCBs separated by V-Cuts. This mode does not make much sense for mousebites in practice. Note that in this mode the cuts do not faithfully copy the PCB outline and, instead, they cut the bounding box of the PCB. There are no other options.
cutout: When your design features open pockets on the side, this parameter specifies extra cutout depth in order to ensure that a sharp corner of the pocket can be milled. The default is 1\u00a0mm.patchcorners: The full tabs are appended to the nearest flat face of the PCB. If the PCB has sharp corners, you want to add patches of substrate to these corners. However, if the PCB has fillet or miter, you don't want to apply the patches.Create tabs in the corners of the PCB.
width: The width of tabsAdd tabs based on PCB annotations. Place a footprint kikit:Tab at the edges of your PCB. You can edit the text field prefixed with KIKIT: to adjust the tab parameters. If you want to specify a custom tab symbol (e.g., with predefined) width, you can specify tabfootprints as a list of footprints separated by comma. For example: myLib:Tab2mm, myLib:Tab3mm.
The individual tabs can have the following properties specified in the text field of the component as KIKIT:<propertyname>:
width: width of the tab.Tabs based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginSpecify how to perform the cuts on the tabs separating the board.
Types: none, mousebites, vcuts, layer, plugin
"},{"location":"panelization/cli/#none","title":"None","text":"Do not perform any cuts
"},{"location":"panelization/cli/#mousebites","title":"Mousebites","text":"Use mousebites to
drill - specify drill size for the bitesspacing - specify the spacing of the holesoffset - specify the offset, positive offset puts the cuts into the board, negative puts the cuts into the tabsprolong - distance for tangential prolongation of the cuts (to cut through the internal corner fillets caused by milling)clearance - specify clearance for copper around V-cutscutcurves - true/false - specify if curves should be approximated by straight cuts (e.g., for cutting tabs on circular boards)offset - specify the offset, positive offset puts the cuts into the board, negative puts the cuts into the tabslayer - specify the layer to render V-cuts on.linewidth - specify linewidthendprolongation - prolongation of the cut line from the board line on the side without text.textprolongation - the same as above, just on the text sidetextoffset - offset of the text from the cut linetemplate - a string template for text to render. Can contain variables listed below, e.g., V-CUT {pos_mm}.pos_mm, pos_inch \u2013 position of the V-cut from the panel originpos_inv_mm, pos_inv_inch \u2013 inverted position of the V-cut from the panel originWhen KiKit reports it cannot perform cuts, you can render the cuts into a layer with this option to understand what's going on. Shouldn't be used for the final design.
layer - specify the layer to render the cuts on.prolong - distance for tangential prolongation of the cuts. It has the same meaning as mousebites.linewidth - width of line to renderCuts based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginKiKit allows you to frame the panel with a full frame, or bottom/top or left/right rails.
Types: none, railstb, railslr, frame, tightframe, plugin Common options:
hspace, vspace, space - specify the space between PCB and the frame/rail. space overrides hspace and vspace.width - specify with of the rails or framefillet, chamfer - fillet/chamfer frame corners. Specify radius or chamfer size. You can also separately specify chamferwidth and chamferheight to create a non 45\u00b0 chamfer.mintotalheight, mintotalwidth \u2013 if needed, add extra material to the rail or frame to meet the minimal requested size. Useful for services that require minimal panel size.Add rail (either on top and bottom or on left and right) to the panel.
"},{"location":"panelization/cli/#frame","title":"Frame","text":"Add a frame around the board.
cuts - one of none, both, v, h - specify whether to add cuts to the corners of the frame for easy removal. Default both.Add a frame around the board which fills the whole area of the panel - the boards have just a milled slot around their perimeter.
slotwidth - width of the milled slot.Frame based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd tooling holes to the (rail/frame of) the panel. The holes are positioned by
Types: none, 3hole, 4hole, plugin
Common options:
hoffset, voffset - specify the offset from from panel edgessize - diameter of the holespaste - if true, the holes are included in the paste layer (therefore they appear on the stencil).solderMaskMargin - diameter of solder mask (optional)Tooling based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd fiducial to the (rail/frame of) the panel.
Types: none, 3fid, 4fid, plugin
Common options:
hoffset, voffset - specify the offset from from panel edgescoppersize, opening - diameter of the copper spot and solder mask openingpaste - if true, the fiducials are included in the paste layer (therefore they appear on the stencil).Fiducials based on a plugin.
code: the plugin specification. See (plugin documentation)[plugin.md] for more detailsarg: text argument for the user pluginAdd text to the panel. Allows you to put a single block of text on panel. You can use variables enclosed in {}. E.g. {boardTitle} | {boardDate}. The list of all available variables in listed bellow. You can also use the variables specified in the project. They are prefixed with user-. That is, to include your variable revision in KiKit text, use formatting string Rev: {user-revision}. In the case you need more independent texts on the panel, you can use sections names text2, text3 and text3 to add at most 4 text. All these sections behave the same and accept the same options.
If you need more texts or more sophisticated placing options, see script option from postprocess.
Types: none, simple
Common options:
text - The text to be displayed. Note that you can escape ; via \\anchor - Origin of the text. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). The anchors refer to the panel outline. Default mthoffset, voffset - specify the offset from anchor. Respects KiCAD coordinate system. Default 0mm.orientation - specify the orientation (angle). Default 0degwidth, height - width and height of the characters (the same parameters as KiCAD uses). Default 1.5mm.hjustify - justification of the text. One of left, right, center. Default center.vjustify - justification of the text. One of top, bottom, center. Default centerthickness - stroke thickness. Default 0.3mm.layer - specify text layerplugin - specify the plugin that provides extra variables for the textdate - formats current date as <year>-<month>-<day>time24 - formats current time in 24-hour formatyear, month, day, hour, minute, second - individual variables for any date formatboardTitle - the title from the source boardboardDate - the date from the source boardboardRevision - the revision from the source boardboardCompany - the company from the source boardboardComment1-boardComment9 - comments from the source boardYou can get extra variables by providing custom text plugin via the plugin field.
Sets page size on the resulting panel and position the panel in the page. The type of style dictates paper size. The default inherit option inherits paper size from the source board. This feature is not supported on KiCAD 5
Types: inherit, custom, A0, A1, A2, A3, A4, A5, A, B, C, D, E, USLetter, USLegal, USLedger, A0-portrait, A1-portrait, A2-portrait, A3-portrait, A4-portrait, A5-portrait, A-portrait, B-portrait, C-portrait, D-portrait, E-portrait, USLetter-portrait, USLegal-portrait, USLedger-portrait
Common options:
anchor - Point of the panel to be placed at given position. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). The anchors refer to the panel outline. Default mtposx, posy - the position of the panel on the page. Default 50% for posx and 20mm for posy.Instead of the pre-defined paper size you can also specify a custom paper size via width and height.
Fill non-board areas of the panel with copper.
Types: none, solid, hatched, hex
Common options:
clearance - optional extra clearance from the board perimeters. Suitable for, e.g., not filling the tabs with copper.edgeclearance - specifies clearance between the fill and panel perimeter.layers - comma-separated list of layer to fill. Default top and bottom. You can specify a shortcut all to fill all layers.Fill with solid copper.
"},{"location":"panelization/cli/#hatched","title":"Hatched","text":"Use hatch pattern for the fill.
width - the width of the strokesspacing - the space between the strokesorientation - the orientation of the strokesUse hexagon pattern for the fill.
diameter \u2013 diameter of the hexagonsspacing \u2013 space between the hexagonsthreshold \u2013 a percentage value that will discard fragments smaller than given thresholdFinishing touches to the panel.
Types: auto
Common options:
copperfill - fill tabs and frame with copper (e.g., to save etchant or to increase rigidity of flex-PCB panels)millradius - simulate the milling operation (add fillets to the internal corners). Specify mill radius (usually 1 mm). 0 radius disables the functionality.millradiusouter \u00ad\u2013 same as the previous one, modifies only board outer counter. No internal features of the board are affected.reconstructarcs - the panelization process works on top of a polygonal representation of the board. This options allows to reconstruct the arcs in the design before saving the panel.refillzones \u2013 refill the user zones after the panel is build. This is only necessary when you want your zones to avoid cuts in panel.script - a path to custom Python file. The file should contain a function kikitPostprocess(panel, args) that receives the prepared panel as the kikit.panelize.Panel object and the user-supplied arguments as a string - see scriptarg. The function can make arbitrary changes to the panel - you can append text, footprints, alter labels, etc. The function is invoked after the whole panel is constructed (including all other postprocessing). If you try to add a functionality for a common fabrication houses via scripting, consider submitting PR for KiKit.scriptarg: An arbitrary string passed to the user post-processing script specified in scriptorigin - specify if the auxilary origin an grid origin should be placed. Can be one of tl, tr, bl, br (corners), mt, mb, ml, mr (middle of sides), c (center). Empty string does not changes the origin.dimensions - true or false. Draw dimensions with the panel size.edgewidth \u00ad\u2013 width of the line for panel edges (that is the lines in the Edge.Cuts layer).This document will show you several examples of KiKit CLI for panelization. Note that this is not an exhaustive description of everything that KiKit can do, nor proper documentation. For further details, please refer to:
We will show everything on a single board located in docs/resources/conn.kicad_pcb. The board looks like this when rendered via PcbDraw:
Let's start with our first panel.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2;' \\\n --tabs full \\\n --cuts vcuts \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2;\" ^\n --tabs full ^\n --cuts vcuts ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe specified that we want 2x2 panel, no space between board and separate them by V-cuts. We also specified that we want to build full tabs (although no tabs are visible in this example). This is ,however, essential \u2013 if we omitted tabs, no cuts between the boards would be performed. Note, that due to the rounded corners, this panel cannot be manufactured. We will fix it later.
Note that the \\ in the input is there to make shell happy, so we can break our command into multiple lines. Also note that there are single quotes around the key-value pair \u2013 again, to make shell happy and to interpret a string with spaces as a single option.
Note that on Windows you have the enter the commands into KiCAD Command Prompt instead of the regular Command Prompt. You can find it under the Start menu.
Also note that KiKit accepts all options in categories (e.g., layout, tabs, cuts, ...). You can specify the parameters as a semicolon-separated key-value list. To learn about the precise syntax of the CLI and about all options, please refer to \u2013 documentation.
One side note \u2013 if you try it with your own board some components might be gone. KiKit respects the KiCAD component selection criteria. When you specify an input rectangle, only the components that fully fit inside the input rectangle are selected. This however take in account both name and value labels (even when they are hidden).
When you do not specify the source are explicitly, KiKit takes the board outline bounding box as the source area. Therefore, by default, components outside the board substrate are not copied to panel.
Note that this is intended behavior; for once it is consistent with KiCAD behavior of user selection and also it allows to easily ignore surrounding comments and drawings in the board sheet (it makes no sense to have 12 same copies of the notes around the board).
How to include the missing components? - specify the source area explicitly to include all your components - specify --source 'tolerance: 10mm' to enlarge the board outline bounding box by e.g. 10 mm. The default value is 1 mm.
I told you that the panel above is not suitable for manufacturing. Let's see why:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2;' \\\n --tabs full \\\n --cuts vcuts \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2;\" ^\n --tabs full ^\n --cuts vcuts ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe specified a milling simulation post-processing. This simulates the milling operation in the fab house. As you can see, the sharp internal corners cannot be manufactured. I recommend you to use milling postprocessing always \u2013 you can easily see if your cuts are off or you have too narrow slots in your design.
Usually, one would use full tabs only for rectangular boards. Usually, when you have rounded corners, you will use short tabs instead and add some space between the boards. So let's fix it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; hwidth: 10mm; vwidth: 15mm' \\\n --cuts vcuts \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; hwidth: 10mm; vwidth: 15mm\" ^\n --cuts vcuts ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIn that way, the rounded corners can be machined. Lets' see the same example with mousebites instead:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 5mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 5mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWe changed cut type to mousebites and we specified that they should be performed by 0.5mm holes with a spacing of 1 mm. You could also use inches if you want \u2013 just specify `in. Since we use mousebites, we used narrower tabs. We also specified that the cuts should be inset 0.25 mm into the board outline. This is suitable when your board should fit into a cover \u2013 when you break away the tabs, all burs will be inside the intended board outline.
What happens, when we simulate the milling operation?
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 5mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 5mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSee? The cuts are somewhat short. This is due to the internal corners that cannot be milled. KiKit can fix that for you \u2013 just specify you want to prolong your cuts tangentially by a small amount:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you want, you can also specify a number of tabs to generate. KiKit will place them evenly:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nYou can also append frame or rails to the panel. Frames and rail are useful in the following situations:
Let's start with rails:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSimilarly, you can add left and right rail via the railslr type. If you want a full frame, use the type frame. When you place a full frame, it might make sense to include cuts in the corner of the frame, so you can break it apart easily. Let's see an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote that you can also use just only a vertical or horizontal frame cuts:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: h' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: h\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen you use V-cuts it might make sense to not remove all material, but only mill a slot around the board of the board. This yields a stronger panel \u2013 and some manufacturers require such style for assembly with V-Cuts. This is achieved via framing type tightframe. Note that it does not make much sense with mousebites.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 6mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts vcuts \\\n --framing 'tightframe; width: 5mm; space: 3mm; ' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 6mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts vcuts ^\n --framing \"tightframe; width: 5mm; space: 3mm; \" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nOnce we have a frame, we can append a tooling holes, fiducials and some text to it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you want to add text to both rails, you can use section --text2 to add a second text. You can also use variables enclosed in curly brackets ({}). The list of supported variables is listed in the documentation. Also, plugins can introduce new variables.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --text2 'simple; text: Created on {date}; anchor: mb; voffset: -2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --text2 \"simple; text: Created on {date}; anchor: mb; voffset: -2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nThere are many options for text and fiducials. Be sure to read the full documentation.
If you have an automatic feeder in your PNP machine or you just dislike sharp corners, you can add a chamfer or a fillet to the panel frame/rails:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm; fillet: 1mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm; fillet: 1mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nPanelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm; chamfer: 1mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm; chamfer: 1mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nSome services, e.g., JLC PCB require a minimal panel size. If you want to ensure that your panel meets the criteria, you can specify minimal total width/height of the panel. Let's see an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; mintotalheight: 100mm; mintotalwidth: 100mm' \\\n --tooling '3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm' \\\n --fiducials '3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;' \\\n --text 'simple; text: yaqwsx's panel with minimal dimensions; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; mintotalheight: 100mm; mintotalwidth: 100mm\" ^\n --tooling \"3hole; hoffset: 2.5mm; voffset: 2.5mm; size: 1.5mm\" ^\n --fiducials \"3fid; hoffset: 5mm; voffset: 2.5mm; coppersize: 2mm; opening: 1mm;\" ^\n --text \"simple; text: yaqwsx's panel with minimal dimensions; anchor: mt; voffset: 2.5mm; hjustify: center; vjustify: center;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIt is possible that you have some critical features you want to avoid with tabs. KiKit has several features that can help you. Let's start with the simple ones.
First, you can rotate the boards in your layout. This might make not much sense for rectanglar boards, but it might save you when you have circular or oddly shaped boards:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 0mm; rotation: 45deg;' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.75mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 0mm; rotation: 45deg;\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.75mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen your board has a connector sticking one one side of the board, it makes sense to rotate the boards every other column, row or combination of both. KiKit supports this via layout option alternation. You should be careful about component references when rotating boards \u2013 KiCAD's references have a property \"Stay upright\" which makes them always face up (even when placed on a panel). So be sure to turn it off before panelizing. Here's an example:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 3mm; alternation: cols;' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'frame; width: 5mm; space: 3mm; cuts: both' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 3mm; alternation: cols;\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"frame; width: 5mm; space: 3mm; cuts: both\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nAnother solution might be to not put tabs on, e.g., vertical edges of the PCB. However, in that case your panel might be weak for further assembly. You can make it more stiff by including backbones \u2013 a full piece of substrate between the panels. You can add either vertical, horizontal or both backbones. Also, similarly with frames, you can put cuts on your backbone to make depanelization of your boards easier. Enough theory, let's see an example
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm; hbackbone: 5mm; hbonecut: true' \\\n --tabs 'fixed; width: 3mm; vcount: 2; hcount: 0' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm; hbackbone: 5mm; hbonecut: true\" ^\n --tabs \"fixed; width: 3mm; vcount: 2; hcount: 0\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nOften, not all backbones are needed. Especially for larger panels. Therefore, if you want, you can skip some of them. Consider the following 4\u00d74 panel with only ever other backbone:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 4; cols: 4; space: 2mm; hbackbone: 5mm; vbackbone: 5mm; hboneskip: 1; vboneskip: 1' \\\n --tabs 'fixed; width: 3mm; vcount: 2; hcount: 0' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 4; cols: 4; space: 2mm; hbackbone: 5mm; vbackbone: 5mm; hboneskip: 1; vboneskip: 1\" ^\n --tabs \"fixed; width: 3mm; vcount: 2; hcount: 0\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nThe most powerful feature of KiKit regarding tab placement are tabs via annotation. Remember our test board? When you open it in Pcbnew, you can see that there are some special footprints \u2013 KiKit's annotations:
They specify where to place tabs. You can even specify individual tab width via text property of the symbol. How to use it? Just specify tab type to annotation. We also have to increase the source area tolerance, so it can capture the annotations.
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 5mm;' \\\n --tabs annotation \\\n --source 'tolerance: 15mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 5mm;\" ^\n --tabs annotation ^\n --source \"tolerance: 15mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWell, the panel looks strange \u2013 right? That's because KiKit always constructs a half-bridges. When you specify the tabs location, you have to either ensure they match or put a piece of substrate they can reach \u2013 e.g., a backbone or a tightframe. If you are interested in the details, read more about tabs in section Understanding tabs. Let's fix it:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm; hbackbone: 3mm; vbackbone: 3mm' \\\n --tabs annotation \\\n --source 'tolerance: 15mm' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm; hbackbone: 3mm; vbackbone: 3mm\" ^\n --tabs annotation ^\n --source \"tolerance: 15mm\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote that the annotation can have an arbitrary orientation. The arrow just must be outside board edge and points towards it. KiKit will also place only those tabs, that have a neighboring substrate. For precise algorithm, see section understanding tabs.
When you make flex PCBs or you want to save etchant, it make sense to pour copper on all non-functional parts of the panel. It will make the PCB rigid. You can do so via copperfill section:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill solid \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill solid ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nWhen you use V-cuts with copperfill you (or your fab house) might want to include a clearance around the V-cuts:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; hwidth: 10mm; vwidth: 15mm' \\\n --cuts 'vcuts; clearance: 1.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill solid \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; hwidth: 10mm; vwidth: 15mm\" ^\n --cuts \"vcuts; clearance: 1.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill solid ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nIf you, for example do not wish to cover the tabs with copper, you can also specify clearance. Also, some manufacturers don't like when you have large solid copper areas. In that case, you can use a hatch pattern to fill the area:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm;' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --copperfill 'hatched; clearance: 2mm; spacing: 0.5mm; width: 0.5mm' \\\n --post 'millradius: 1mm;' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm;\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --copperfill \"hatched; clearance: 2mm; spacing: 0.5mm; width: 0.5mm\" ^\n --post \"millradius: 1mm;\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nNote one last facts about V-cuts. V-cuts can only be straight and horizontal/vertical. But you can use them with circular boards if you want by cutting a little inside them. The option cutcurves, that will approximate the cut by staring and ending point.
If you need something special; e.g., custom placement of tooling holes, multiple texts, etc. KiKit has you covered.
The CLI interface allows you to run a custom script over the final panel. The script can use KiKit Python interface to modify it. For the sake of simplicity, let's add a hole in the middle of the frame. Therefore, we write the following script:
from kikit.units import mm\nfrom kikit.common import toKiCADPoint\n\ndef kikitPostprocess(panel, arg):\n minx, miny, maxx, maxy = panel.panelBBox()\n position = toKiCADPoint(((minx + maxx) // 2, miny + 2 * mm))\n panel.addNPTHole(position, 3 * mm)\nThen run KiKit:
Panelization command
Linux/macOSWindowskikit panelize \\\n --layout 'grid; rows: 2; cols: 2; space: 2mm' \\\n --tabs 'fixed; width: 3mm; vcount: 2' \\\n --cuts 'mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm' \\\n --framing 'railstb; width: 5mm; space: 3mm;' \\\n --post 'millradius: 1mm; script: docs/resources/examplePost.py' \\\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nkikit panelize ^\n --layout \"grid; rows: 2; cols: 2; space: 2mm\" ^\n --tabs \"fixed; width: 3mm; vcount: 2\" ^\n --cuts \"mousebites; drill: 0.5mm; spacing: 1mm; offset: 0.2mm; prolong: 0.5mm\" ^\n --framing \"railstb; width: 5mm; space: 3mm;\" ^\n --post \"millradius: 1mm; script: docs/resources/examplePost.py\" ^\n docs/resources/conn.kicad_pcb panel.kicad_pcb\nYou can learn more about available functions from the comment in the source code or in the Python API reference. The basic concepts are summarized in the scripting guide.
If you implement a feature that your fab house requires (e.g., new tooling hole type), consider submitting a pull request for KiKit instead. I believe the others will benefit from it.
"},{"location":"panelization/examples/#managing-presets","title":"Managing presets","text":"The last section of this document is dedicated to management of presets. You can read the specification in the documentation for CLI. Here I would like to focus on practical examples.
As you should know from the documentation, the panelization preset is divided into sections; e. g., layout, tabs, etc. The key-value parameters in these sections can be specified via JSON files. In KiKit, you can specify these files via -p option:
kikit panelize -p myPreset.json -p :<builtInPreset> <other parameters>
The parameters in the later specified presets override the parameters in the previously specified presets. This allows you to define a named piece-wise presets. Therefore, you can prepare various presets for mousebites \u2013 e.g., fineMousebites.json and coarseMousebites.json:
// fineMousebites.json\n{\n \"cuts\": {\n \"type\": \"mousebites\", \"drill\": \"0.5mm\", \"spacing\": \"0.9mm\", \"offset\":\n \"0.25mm\"\n }\n}\n\n// coarseMousebites.json\n{\n \"cuts\": {\n \"type\": \"mousebites\", \"drill\": \"0.3mm\", \"spacing\": \"0.2mm\", \"offset\":\n \"0.15mm\"\n }\n}\nThen you can specify your panelization commands easily via:
kikit panelize -p fineMousebites.json <otheroptions>
Therefore, you can build a custom library of commonly used-options; e.g., per fabrication house. KiKit offers some built-in presets \u2013 see panelizePresets. Note that the built-in preset default.json is always used as a base and it specifies conservative default values so you can only override the options relevant for you.
To give you an example \u2013 with KiKit, you will no longer have to remember what diameter of tooling holes JLC PCB requires, just use:
kikit panelize -p :jlcTooling <otheroptions>
The panelization feature of KiKit is also available via GUI in the KiCAD's PCB editor (Pcbnew). The main use-case for the GUI is to quickly construct the desired KiKit command and fine-tune the panel. It also serves as a quick help in case you are not sure about parameter naming.
The GUI is designed to be run in a standalone instance of Pcbnew (not executed from a project) as the generated panel replaces the currently open board.
You can invoke the GUI via clicking on the panelization icon:
Then the following window will open:
There are three parts of the window:
Note that both, the command and JSON preset, does not include a parameter if it is the same with the default, built-in, preset.
Once you are happy with the parameters, you can click the \"Panelize\" button and the panel will appear in the Pcbnew work area. You can then edit the parameters and regenerate the panel. The panel you see in the Pcbnew window is only a preview. The panel is automatically saved to the specified location upon creation.
"},{"location":"panelization/intro/","title":"Automatic panelization with KiKit","text":"KiKit panelization module is designed to:
There are two ways of specifying a panel:
To tweak the KiKit UI process it is possible to use plugins. Plugins are pieces of Python code that provide some functionality. They can save you from writing a custom panelization script from scratch when you only need a custom one of the steps during panelization.
"},{"location":"panelization/plugins/#specifying-plugins","title":"Specifying plugins","text":"Some of the CLI options allow you to specify plugin. In such a case, one of the following formats is expected:
<packagename>.<pluginname>, e.g., ExternalPackage.CircleLayout<filename>.<pluginname>, e.g., localFile.py.CircleLayoutAll plugins, except text plugins, accept optional user text argument.
The plugins can be implemented and published as Python packages.
"},{"location":"panelization/plugins/#writing-custom-plugins","title":"Writing custom plugins","text":"The plugins should be implemented by overriding one of the plugin types specified in ../kikit/plugin.py. Currently, the following plugin types are supported:
HookPlugin - this is a plugin that features a number of callback that are invoked during various stages of building the panel. You can tweak the panels in these callbacks.LayoutPlugin - this plugin implements a new layout of the boards in the panel.FramingPlugin - this plugin implements a new style of framing.TabsPlugin - this plugin implements a new style of tab placement.CutsPlugin - this plugin implements a new style of cut rendering.ToolingPlugin - this plugin implements a new style of tolling decoration.FiducialsPlugin - this plugin implements a new style of fiducials decoration.TextVariablePlugin - this plugins provides new variables for the text placement.All plugins except TextVariablePlugin have attributes self.preset containing the whole preset and self.userArg containing the string provided by the user.
When you want to panelize a board, you are expected to load the kikit.panelize module and create an instance of the Panel class.
All units are in the internal KiCAD units (1 nm). You can use predefined constants to convert from/to them:
from kikit.units import *\n\nl = 1 * mm # 1 mm\nl = 42 * inch # 42 inches\nl = 15 * cm # 15 cm\na = 90 * deg # 90\u00b0\na = 1 * rad # 1 radian\nYou can also use functions fromMm(mm) and toMm(kiUnits) to convert to/from them if you like them more. You are also encouraged to use the functions and objects the native KiCAD Python API offers, e.g.: VECTOR2I(args),BOX2I(args).
The kikit.panelize.Panel class holds a panel under construction. Basically it is pcbnew.BOARD without outlines. The outlines are held separately as shapely.MultiPolygon so we can easily merge pieces of a substrate, add cuts and export it back to pcbnew.BOARD. This is all handled by the class kikit.substrate.Substrate.
There are two ways to create tabs: generate a piece of a substrate by hand, or use tab generator.
To generate a piece of a substrate, create a shapely.Polygon. Then add the piece of substrate via panelize.Panel.appendSubstrate. This method also accepts a BOX2I for convenience.
The tab generator is available via panelize.Panel.boardSubstrate.tab. This method takes an origin point, direction, and tab width. It tries to build a tab by extruding a tab with the given width in the given direction and stops when it reaches an existing substrate. It returns a tuple - the tab substrate and a piece of the outline of the original board, which was removed by the tab. Then add the piece of a substrate via panelize.Panel.appendSubstrate. This design choice was made as batch adding of substrates is more efficient. Therefore, you are advised to first generate all the tabs and then append them to the board.
You read more about the algorithms for generating tabs in a separate document understanding tabs.
"},{"location":"panelization/python_api/#cuts","title":"Cuts","text":"All methods constructing panels do not create cuts directly, instead, they return them. This allows the users to decided how to perform the cuts - e.g., mouse bites, V-Cuts, silk-screen...
The cuts are represented by shapely.LineString. The string is oriented - a positive side of the string should face the inner side of the board. This is important when, e.g., offsetting mouse bites.
To perform the cuts, see methods of the panelize.Panel class below.
When placing a board, you might specify source area -- a rectangle from which the components are extracted. If no source area is specified, the smallest bounding box of all Edge.Cuts is taken.
Only components that fully fit inside source area are copied to the panel. To include components sticking out of the board outline, you can specify tolerance -- a distance by which the source area is expanded when copying components.
"},{"location":"panelization/python_api/#appendboard","title":"appendBoard","text":"appendBoard(self, filename, destination, sourceArea=None, origin=Origin.Center, \n rotationAngle=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3120> >, \n shrink=False, tolerance=0, bufferOutline=1000, netRenamer=None, \n refRenamer=None, inheritDrc=True, interpretAnnotations=True, \n bakeText=False)\nThis class has the following relevant members: - board - pcbnew.BOARD of the panel. Does not contain any edges. - substrates - kikit.substrate.Substrate - individual substrates appended via None. You can use them to get the original outline (and e.g., generate tabs accroding to it). - boardSubstrate - kikit.substrate.Substrate of the whole panel. - backboneLines - a list of lines representing backbone candidates. Read more about it in understanding tabs.
addCornerChamfers","text":"addCornerChamfers(self, horizontalSize, verticalSize=None)\naddCornerFiducials","text":"addCornerFiducials(self, fidCount, horizontalOffset, verticalOffset, \n copperDiameter, openingDiameter, paste=False)\nThe offsets are measured from the outer edges of the substrate.
"},{"location":"panelization/python_api/#addcornerfillets","title":"addCornerFillets","text":"addCornerFillets(self, radius)\naddCornerTooling","text":"addCornerTooling(self, holeCount, horizontalOffset, verticalOffset, diameter, \n paste=False, solderMaskMargin=None)\nThe offsets are measured from the outer edges of the substrate.
Optionally, a solder mask margin (diameter) can also be specified.
"},{"location":"panelization/python_api/#addfiducial","title":"addFiducial","text":"addFiducial(self, position, copperDiameter, openingDiameter, bottom=False, \n paste=False, ref=None)\nVECTOR2I), with given copperDiameter and openingDiameter. By setting bottom to True, the fiducial is placed on bottom side. The fiducial can also have an opening on the stencil. This is enabled by paste = True."},{"location":"panelization/python_api/#addkeepout","title":"addKeepout","text":"addKeepout(self, area, noTracks=True, noVias=True, noCopper=True)\naddLine","text":"addLine(self, start, end, thickness, layer)\naddMillFillets","text":"addMillFillets(self, millRadius)\naddNPTHole","text":"addNPTHole(self, position, diameter, paste=False, ref=None, \n excludedFromPos=False)\nVECTOR2I) with given diameter. The paste option allows to place the hole on the paste layers."},{"location":"panelization/python_api/#addpaneldimensions","title":"addPanelDimensions","text":"addPanelDimensions(self, layer, offset)\naddTabMillFillets","text":"addTabMillFillets(self, millRadius)\naddText","text":"addText(self, text, position, \n orientation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f37b0> >, \n width=1500000, height=1500000, thickness=300000, \n hJustify=EDA_TEXT_HJUSTIFY_T.GR_TEXT_HJUSTIFY_CENTER, \n vJustify=EDA_TEXT_VJUSTIFY_T.GR_TEXT_VJUSTIFY_CENTER, \n layer=Layer.F_SilkS)\naddVCutH","text":"addVCutH(self, pos)\naddVCutV","text":"addVCutV(self, pos)\nappendBoard","text":"appendBoard(self, filename, destination, sourceArea=None, origin=Origin.Center, \n rotationAngle=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3120> >, \n shrink=False, tolerance=0, bufferOutline=1000, netRenamer=None, \n refRenamer=None, inheritDrc=True, interpretAnnotations=True, \n bakeText=False)\nThe sourceArea (BOX2I) of the board specified by filename is extracted and placed at destination (VECTOR2I). The source area (BOX2I) can be auto detected if it is not provided. Only board items which fit entirely into the source area are selected. You can also specify rotation. Both translation and rotation origin are specified by origin. Origin specifies which point of the sourceArea is used for translation and rotation (origin it is placed to destination). It is possible to specify coarse source area and automatically shrink it if shrink is True. Tolerance enlarges (even shrinked) source area - useful for inclusion of filled zones which can reach out of the board edges or footprints that extend outside the board outline, like connectors.
You can also specify functions which will rename the net and ref names. By default, nets are renamed to \"Board_{n}-{orig}\", refs are unchanged. The renamers are given board seq number and original name.
You can also decide whether you would like to inherit design rules from this boards or not.
Similarly, you can substitute variables in the text via bakeText.
Returns bounding box (BOX2I) of the extracted area placed at the destination and the extracted substrate of the board.
"},{"location":"panelization/python_api/#appendsubstrate","title":"appendSubstrate","text":"appendSubstrate(self, substrate)\napply","text":"apply(self, feature)\nboardsBBox","text":"boardsBBox(self)\nbuildFullTabs","text":"buildFullTabs(self, cutoutDepth, patchCorners=True)\nReturn a list of cuts.
"},{"location":"panelization/python_api/#buildpartitionlinefrombb","title":"buildPartitionLineFromBB","text":"buildPartitionLineFromBB(self, boundarySubstrates=[], safeMargin=0)\nbuildTabAnnotationsCorners","text":"buildTabAnnotationsCorners(self, width)\nbuildTabAnnotationsFixed","text":"buildTabAnnotationsFixed(self, hcount, vcount, hwidth, vwidth, minDistance, \n ghostSubstrates)\nIf the edge is short for the specified number of tabs with given minimal spacing, the count is reduced.
You can also specify ghost substrates (for the future framing).
"},{"location":"panelization/python_api/#buildtabannotationsspacing","title":"buildTabAnnotationsSpacing","text":"buildTabAnnotationsSpacing(self, spacing, hwidth, vwidth, ghostSubstrates)\nYou can also specify ghost substrates (for the future framing).
"},{"location":"panelization/python_api/#buildtabsfromannotations","title":"buildTabsFromAnnotations","text":"buildTabsFromAnnotations(self, fillet)\nExpects that a valid partition line is assigned to the the panel.
"},{"location":"panelization/python_api/#cleartabsannotations","title":"clearTabsAnnotations","text":"clearTabsAnnotations(self)\ncopperFillNonBoardAreas","text":"copperFillNonBoardAreas(self, clearance=1000000, \n layers=[<Layer.F_Cu: 0>, <Layer.B_Cu: 31>], \n hatched=False, strokeWidth=1000000, \n strokeSpacing=1000000, \n orientation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3510> >)\nFill given layers with copper on unused areas of the panel (frame, rails and tabs). You can specify the clearance, if it should be hatched (default is solid) or shape the strokes of hatched pattern.
By default, fills top and bottom layer, but you can specify any other copper layer that is enabled.
"},{"location":"panelization/python_api/#debugrenderbackbonelines","title":"debugRenderBackboneLines","text":"debugRenderBackboneLines(self)\ndebugRenderBoundingBoxes","text":"debugRenderBoundingBoxes(self)\ndebugRenderPartitionLines","text":"debugRenderPartitionLines(self)\ngetAuxiliaryOrigin","text":"getAuxiliaryOrigin(self)\ngetDruFilepath","text":"getDruFilepath(self, path=None)\ngetGridOrigin","text":"getGridOrigin(self)\ngetPageDimensions","text":"getPageDimensions(self)\ngetPrlFilepath","text":"getPrlFilepath(self, path=None)\ngetProFilepath","text":"getProFilepath(self, path=None)\ninheritCopperLayers","text":"inheritCopperLayers(self, board)\ninheritDesignSettings","text":"inheritDesignSettings(self, board)\ninheritPageSize","text":"inheritPageSize(self, board)\ninheritProperties","text":"inheritProperties(self, board)\ninheritTitleBlock","text":"inheritTitleBlock(self, board)\nlocateBoard","text":"locateBoard(inputFilename, expandDist=None)\nParameters:
inputFilename - the path to the board file
expandDist - the distance by which to expand the board outline in each direction to ensure elements that are outside the board are included
"},{"location":"panelization/python_api/#makecutstolayer","title":"makeCutsToLayer","text":"makeCutsToLayer(self, cuts, layer=Layer.Cmts_User, prolongation=0)\nThe purpose of this is to aid debugging when KiKit refuses to perform cuts. Rendering them into lines can give the user better understanding of where is the problem.
"},{"location":"panelization/python_api/#makeframe","title":"makeFrame","text":"makeFrame(self, width, hspace, vspace, minWidth=0, minHeight=0, maxWidth=None, \n maxHeight=None)\nParameters:
width - width of substrate around board outlines
slotwidth - width of milled-out perimeter around board outline
hspace - horizontal space between board outline and substrate
vspace - vertical space between board outline and substrate
minWidth - if the panel doesn't meet this width, it is extended
minHeight - if the panel doesn't meet this height, it is extended
maxWidth - if the panel doesn't meet this width, TooLargeError is raised
maxHeight - if the panel doesn't meet this height, TooLargeHeight is raised
"},{"location":"panelization/python_api/#makeframecutsh","title":"makeFrameCutsH","text":"makeFrameCutsH(self, innerArea, frameInnerArea, outerArea)\nmakeFrameCutsV","text":"makeFrameCutsV(self, innerArea, frameInnerArea, outerArea)\nmakeGrid","text":"makeGrid(self, boardfile, sourceArea, rows, cols, destination, placer, \n rotation=<pcbnew.EDA_ANGLE; proxy of <Swig Object of type 'EDA_ANGLE *' at 0x7f4b833f3f00> >, \n netRenamePattern=Board_{n}-{orig}, refRenamePattern=Board_{n}-{orig}, \n tolerance=0, bakeText=False)\nParameters:
boardfile - the path to the filename of the board to be added
sourceArea - the region within the file specified to be selected (see also tolerance, below) set to None to automatically calculate the board area from the board file with the given tolerance
rows - the number of boards to place in the vertical direction
cols - the number of boards to place in the horizontal direction
destination - the center coordinates of the first board in the grid (for example, VECTOR2I(100 * mm, 50 * mm))
rotation - the rotation angle to be applied to the source board before placing it
placer - the placement rules for boards. The builtin classes are: BasicGridPosition - places each board in its original orientation OddEvenColumnPosition - every second column has the boards rotated by 180 degrees OddEvenRowPosition - every second row has the boards rotated by 180 degrees OddEvenRowsColumnsPosition - every second row and column has the boards rotated by 180 degrees
netRenamePattern - the pattern according to which the net names are transformed The default pattern is \"Board_{n}-{orig}\" which gives each board its own instance of its nets, i.e. GND becomes Board_0-GND for the first board , and Board_1-GND for the second board etc
refRenamePattern - the pattern according to which the reference designators are transformed The default pattern is \"Board_{n}-{orig}\" which gives each board its own instance of its reference designators, so R1 becomes Board_0-R1 for the first board, Board_1-R1 for the second board etc. To keep references the same as in the original, set this to \"{orig}\"
tolerance - if no sourceArea is specified, the distance by which the selection area for the board should extend outside the board edge. If you have any objects that are on or outside the board edge, make sure this is big enough to include them. Such objects often include zone outlines and connectors.
bakeText - substitute variables in text elements
Returns a list of the placed substrates. You can use these to generate tabs, frames, backbones, etc.
"},{"location":"panelization/python_api/#makelayersvisible","title":"makeLayersVisible","text":"makeLayersVisible(self)\nmakeMouseBites","text":"makeMouseBites(self, cuts, diameter, spacing, offset=250000, prolongation=500000)\nmakeRailsLr","text":"makeRailsLr(self, thickness, minWidth=0, maxWidth=None)\nmakeRailsTb","text":"makeRailsTb(self, thickness, minHeight=0, maxHeight=None)\nmakeTightFrame","text":"makeTightFrame(self, width, slotwidth, hspace, vspace, minWidth=0, minHeight=0, \n maxWidth=None, maxHeight=None)\nParameters:
width - width of substrate around board outlines
slotwidth - width of milled-out perimeter around board outline
hspace - horizontal space between board outline and substrate
vspace - vertical space between board outline and substrate
minWidth - if the panel doesn't meet this width, it is extended
minHeight - if the panel doesn't meet this height, it is extended
maxWidth - if the panel doesn't meet this width, TooLargeError is raised
maxHeight - if the panel doesn't meet this height, TooLargeHeight is raised
"},{"location":"panelization/python_api/#makevcuts","title":"makeVCuts","text":"makeVCuts(self, cuts, boundCurves=False, offset=0)\npanelBBox","text":"panelBBox(self)\npanelCorners","text":"panelCorners(self, horizontalOffset=0, verticalOffset=0)\nrenderBackbone","text":"renderBackbone(self, vthickness, hthickness, vcut, hcut, vskip=0, hskip=0, \n vfirst=0, hfirst=0)\nvcut, hcut specifies if vertical or horizontal backbones should be cut.
vskip and hskip specify how many backbones should be skipped before rendering one (i.e., skip 1 meand that every other backbone will be rendered)
vfirst and hfirst are indices of the first backbone to render. They are 1-indexed.
Return a list of cuts
"},{"location":"panelization/python_api/#save","title":"save","text":"save(self, reconstructArcs=False, refillAllZones=False)\nsetAuxiliaryOrigin","text":"setAuxiliaryOrigin(self, point)\nsetCopperLayers","text":"setCopperLayers(self, count)\nsetDesignSettings","text":"setDesignSettings(self, designSettings)\nsetGridOrigin","text":"setGridOrigin(self, point)\nsetPageSize","text":"setPageSize(self, size)\nsetProperties","text":"setProperties(self, properties)\nsetTitleBlock","text":"setTitleBlock(self, titleBlock)\nsetVCutClearance","text":"setVCutClearance(self, clearance)\nsetVCutLayer","text":"setVCutLayer(self, layer)\ntransferProjectSettings","text":"transferProjectSettings(self)\nAlso, transfers the list of net classes from the internal representation into the project file.
"},{"location":"panelization/python_api/#translate","title":"translate","text":"translate(self, vec)\nwriteCustomDrcRules","text":"writeCustomDrcRules(self)\nThis class represents a pice of substrate (with no components). Basically it is just a relatively thin wrapper around shapely polygons. On top of that, it keeps a partition line for the substrate. Read more about partition lines in understanding tabs.
"},{"location":"panelization/python_api/#backtosource","title":"backToSource","text":"backToSource(self, point)\nboundary","text":"boundary(self)\nboundingBox","text":"boundingBox(self)\nbounds","text":"bounds(self)\ncut","text":"cut(self, piece)\nexterior","text":"exterior(self)\nexteriorRing","text":"exteriorRing(self)\ninteriors","text":"interiors(self)\nisSinglePiece","text":"isSinglePiece(self)\nmidpoint","text":"midpoint(self)\nmillFillets","text":"millFillets(self, millRadius)\norient","text":"orient(self)\nremoveIslands","text":"removeIslands(self)\nserialize","text":"serialize(self, reconstructArcs=False)\ntab","text":"tab(self, origin, direction, width, partitionLine=None, maxHeight=50000000, \n fillet=0)\nWhen partitionLine is specified, the tab is extended to the opposite side - limited by the partition line. Note that if tab cannot span towards the partition line, then the tab is not created - it returns a tuple (None, None).
If a fillet is specified, it allows you to add fillet to the tab of specified radius.
Returns a pair tab and cut outline. Add the tab it via union - batch adding of geometry is more efficient.
"},{"location":"panelization/python_api/#translate_1","title":"translate","text":"translate(self, vec)\nunion","text":"union(self, other)\nThis document will show you how to use KiKit as a library for panelization. The full reference for the available API is located in the next section.
"},{"location":"panelization/scripting/#basic-concepts","title":"Basic concepts","text":"Let's start with an overview of the foundational concepts in KiKit.
"},{"location":"panelization/scripting/#units","title":"Units","text":"All units are in the internal KiCAD units (1 nm). You can use predefined constants to convert from/to them:
from kikit.units import *\n\nl = 1 * mm # 1 mm\nl = 42 * inch # 42 inches\nl = 15 * cm # 15 cm\na = 90 * deg # 90\u00b0\na = 1 * rad # 1 radian\nYou can also use functions fromMm(mm) and toMm(kiUnits) to convert to/from them if you like them more. You are also encouraged to use the functions and objects that the native KiCAD Python API offers, e.g.: pcbnew.wxPoint(args), pcbnew.wxPointMM(mmx, mmy), pcbnew.wxRect(args), pcbnew.wxRectMM(x, y, wx, wy).
When KiKit loads a KiCAD board, it takes the Edge.Cuts layer and tries to interpret it as a set of 2D polygons. If it cannot interpret them (i.e, there is a discontinuous outline), it raises an exception.
These polygons has a notion of what is inside and what is outside. We can also perform boolean operation on them (i.e., merge two polygons, subtract one from the other, etc.). When we save the panel, the polygons are converted back to outlines. All internal operations in KiKit that changes the board shape operate on top of the polygonal representation, not the outline themselves.
The polygonal representation of board shape is called PCB substrate and it is represented by the class kikit.substrate.Substrate. Internally, KiKit uses the library Shapely to represent the polygon. We advise you to get at least briefly familiar with it as whenever you need to create a new piece of substrate (e.g., for a tab) you will do so using the operations Shapely provides.
The Substrate class encapsulates the functionality regarding converting an outline into a polygon and vice-versa and modification of the substrate (add/subtract from it/construct a tab for it). For convenience, it also holds the partition lines associated with the substrate. For more details about partition lines, please refer to section Tabs below.
The panel construction is handled via kikit.panelize.Panel class. This class represents a panel under construction as pcbnew.Board without outlines. The outlines are represented via a substrate and it is converted into outline only on saving the panel to file.
The panel class provides you with a number of methods to construct the panel; e.g., append a board at given coordinates, create a grid of boards, add piece of substrate to it, add framing, create a cut, etc.
A typical workflow with the Panel class is the following:
appendBoard or makeAGrid),buildPartitionLineFromBB or manually set. Without a partition line the automatic tab building nor backbone do not work.During the whole process you can directly access panel.board of the type pcbnew.Board and use the KiCAD API to add or remove the features on the boards.
Every tab consists of two features: a piece of substrate that connects the individual board on the panel and a cut that will be broken when you depanelize the board.
In KiKit, the substrate is represented as a Substrate, more precisely as shapely.geometry.Polygon. This substrate is appended to the resulting panel substrate. The cut is represented as a polyline of the type shapely.geometry.LineString. KiKit accepts the polyline and it can either convert it into mouse bites or V-cuts.
You can build the tab substrate and cuts manually. In that case, just build the tab shape as Polygon and append it to the board via Panel.appendSubstrate. You also construct the cuts manually as LineString and you turn it
Panel.makeMouseBites, orPanel.makeVCuts. You can also use Panel.addVCutV or Panel.addVCutH in this case and avoid creating the LineString.You will use this approach in the simple cases or cases when you need a specially shaped tabs.
The second approach is to let KiKit generate the tabs and cuts automatically based on annotations. Annotation is just a marking on the board outline that specifies \"here should be a tab of this width\". You can read the annotations from source board (there are special footprints for that), generate it manually or use some of the strategies to place the annotations (e.g., place tabs in a spacing or in given number along edges). Note that the strategies often need a properly build partition line. Once you are finished, you can render the tabs using Panel.buildTabsFromAnnotations. This function will merge the tab bodies and returns a list of cuts. With the list of cuts, you can further decide whether to ignore them or render them via mousebites or V-cuts. For more details on the automated process of building tabs from annotations, see understanding tabs.
The document understanding tabs also explains what is a partition line and how it is used. Let us add that partition line is represented as shapely collection of line strings. The partition line is not a single one for the whole panel, but it is stored separately for each appended board as the annotations are rendered independently for each appended board.
Also note that you can use the partition line as guide when placing features (e.g., adding a holes on backbone, etc.).
"},{"location":"panelization/scripting/#appending-boards","title":"Appending Boards","text":"The simples approach to adding boards to a panel is using Panel.appendBoard. This places a board in the panel and also, it renames the nets such that they are panel-wise unique. This is necessary to pass DRC. You can specify the renaming pattern if you want. The substrate of the board is added the panel substrate, but it is also stored separately in Panel.substrates as the shape of the original board can be used to generate the automatic tabs and also it is used to copper-fill the non-board areas of the panel. You can also use these substrates to build your custom features.
If you make single-board panels, you can use the function Panel.makeGrid to quickly place the boards in a grid. The function returns the list of individual substrates. You can use the substrates e.g., to build custom tabs or other features.
When you place multiple PCB into the panel, KiKit expects you to generate a so-called partition line for each individual PCB. Partition line is an oriented (poly)line that partitions the free space between the PCBs. It gives you the information \"this part of the free space belongs to this PCB substrate and this PCB is responsible for placing tabs in that space\". So for a regular input the partition line can look like this:
For more complicated input, it can look like this:
Note several facts: - partition line is used for backbone generator - partition line is not generated automatically, it is up to the user to generate it. KiKit offers Panel.buildPartitionLineFromBB that builds the partition line based on bounding boxes. If you need possibly a more complicated lines, you have to implement them by yourself. - partition line is used for deciding if an annotation yields a tab or not - if the tab does not hit the partition line, it is not created. - when we create partition line from bounding boxes, we include \"ghost substrates\" representing the framing, that will be added in the future.
When KiKit generates a tab, it generates it based on tab origin, direction and optionally the partition line. When a tab is successfully generated, it consists out of two components - a piece of a substrate (which will be later appended to the panel) and a cut-line.
So assume we have the following PCB outline (the PCB is below the line, there is a free space above the line):
Then you specify your tab origin and its direction:
This is your input (e.g., via an annotation). Now KiKit does its job; it shoots two rays tabWidth apart and looks for the intersection with existing substrates. Note that if the ray starts within the PCB, no intersection will be found.
Once we have the intersections, we can easily generate the tab substrate and the cut:
Note that if we specify a partition line, than we shoot new rays in the opposite direction and try to hit the line. If we manage to do so, we get a tab. Otherwise, no tab is generated.
This is the basic algorithm for generating tabs. Well, we might also call them \"half tabs\". KiKit usually generates the half tabs around the board bounding box and then expects that two half tabs in the middle of the panel will merge into a single one. Also, KiKit first generates all the tabs and then merges them in one step to the board substrate. The cut is just a polyline which is in later steps either rendered as a V-cut or via mousebites.
"}]} \ No newline at end of file diff --git a/upstream/sitemap.xml.gz b/upstream/sitemap.xml.gz index 829b953f..050adcc3 100644 Binary files a/upstream/sitemap.xml.gz and b/upstream/sitemap.xml.gz differ diff --git a/upstream/stencil/index.html b/upstream/stencil/index.html index 0d898b6b..135812e1 100644 --- a/upstream/stencil/index.html +++ b/upstream/stencil/index.html @@ -16,7 +16,7 @@ - + @@ -1449,12 +1449,12 @@Many fabhouses offer you to create a custom stencil. However, it is pain to align them. Therefore, KiKit offers a functionality to automatically generate stencils which fit a simple 3D printed or lasercut alignment jig.
-You can find Fusion 360 model of the alignment jig here:
-https://a360.co/3iiFXKp. It it designed to be cut
-from 3mm thick acrylic. You need 4 2mm pins, 8 M2 screws and that's it. The
-frame can be customized - there two parameters of the model, frameWidth and
-frameHeight which define the largest PCB it can accept. I usually use
-100x100mm and 60x60mm.
The jig is available as Fusion 360 model,
+STEP or 3MF.It it designed to be cut
+from 3mm thick acrylic but you can also print it. You need 4 2mm pins, 8 M2
+screws and that's it. The frame can be customized - there two parameters of the
+model, frameWidth and frameHeight which define the largest PCB it can
+accept. I usually use 100x100mm and 60x60mm.
Then you issue the following command within KiKit: