Matlab Assemble Pcb Layout

MathWorksOfficialCreated by MathWorks

Skill
Tool integration
Science and research
BSD-2-Clause
No issues found

From the author

Build custom PCB structures with pcbComponent, shapes, Boolean ops, feeds, and multi-layer stackups for non-catalog geometries. TRIGGER: user asks to build, modify, or customize a pcbComponent — add/remove shapes, edit polygons, place feeds, add metal layers, cut slots, or create non-catalog RF structures. Also when modifying geometry of an existing catalog-designed component (e.g., adding pads, removing elements, editing vertices). Invoke BEFORE writing pcbComponent code — layer/shape/feed API is non-obvious. SKIP: designing catalog components like filters/couplers/txlines (use the specific matlab-design-pcb-* skill), material/stackup definition only (use matlab-manage-pcb-material), EM analysis (use matlab-analyze-em), importing PCB files (use matlab-read-pcb-layout).

— the description by MathWorks

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to assembling custom PCB layouts in MATLAB that fall outside standard catalog components. It covers the creation of multi-layer stackups, the application of Boolean operations to shape primitives, and the configuration of advanced feed definitions. By using the pcbComponent container, users can define precise metal traces, dielectric layers, and ground structures, enabling the design of specialized RF components like defected ground structures (DGS) or custom stripline configurations.

What it does

Constructs custom multi-layer PCB stackups using pcbComponent.
Combines geometric primitives with Boolean union, subtraction, and intersection.
Configures advanced feed types including coaxial, edge, and delta-gap.
Enables the creation of defected ground structures (DGS) for RF performance tuning.
Supports geometric transformations like rotation, mirroring, and scaling.
Provides methods for visualizing 3D structures and 2D layout views.

When to use it

When designing PCB geometries not available in standard component catalogs.
When building multi-layer stripline or shielded enclosure structures.
When etching custom patterns into ground planes to create DGS.
When needing precise control over feed port placement and via geometry.
When combining multiple shape primitives into a single complex component.

Advantages

Enables full design flexibility for non-standard RF PCB geometries.
Integrates seamlessly with MATLAB's EM analysis and optimization workflows.
Provides a programmatic interface for complex geometric manipulation.
Supports advanced feed modeling for accurate simulation of custom ports.

Usage examples

“How do I create a 5-layer stripline structure with a signal layer between two ground planes?”: The agent will guide you to define dielectric and metal layers, set the total board thickness, and assign the layers to a pcbComponent, ensuring the signal layer is correctly indexed.
“I need to etch a dumbbell-shaped slot into my ground plane. How do I do that?”: The agent will show you how to use the dumbbell shape primitive and the dgs method to subtract the pattern from your existing ground plane layer.
“How can I combine two rectangular traces into one shape?”: The agent will demonstrate using the '+' operator to perform a Boolean union on two traceRectangular objects.
“How do I set up an edge feed for a stripline design?”: The agent will explain how to switch to the FeedDefinitions API and configure an EdgeFeed object with the appropriate signal and ground layer indices.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/matlab/matlab-assemble-pcb-layout/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip matlab-assemble-pcb-layout.zip -d .agents/skills

Documentation by MathWorks

Assembling Custom PCB Components

When to Use

Building custom PCB structures that aren't covered by catalog objects (microstripLine, coupledMicrostripLine, etc.)
Constructing multi-layer stackups with custom metal shapes on each layer
Combining shape primitives with Boolean operations (union, subtract, intersect)
Creating defected ground structures (DGS) by etching patterns into ground planes
Placing feed ports, vias, or using advanced FeedDefinitions (coaxial, edge, delta-gap)
Assembling stripline or shielded enclosure structures

When NOT to Use

Designing standard transmission lines — use matlab-design-pcb-transmission-line
Importing layouts from Gerber, ODB++, or Allegro — use matlab-read-pcb-layout
Defining dielectric or metal materials — use matlab-manage-pcb-material
Running EM analysis after assembly — use matlab-analyze-em
Cascading or connecting multiple pcbComponents — use matlab-integrate-pcb-circuit

Typical Workflow

Before: matlab-manage-pcb-material — set up substrate and conductor
This skill: Build the custom PCB structure using pcbComponent, shapes, and feeds
After: matlab-analyze-em — validate S-parameters → matlab-optimize-pcb-design — tune dimensions → matlab-write-pcb-layout — export Gerber

Quick Reference

Task	Code
Create pcbComponent	`pcb = pcbComponent`
Assign layers	`pcb.Layers = {signal, substrate, ground}`
Set board shape	`pcb.BoardShape = ground`
Set thickness	`pcb.BoardThickness = 1.6e-3`
Place feeds	`pcb.FeedLocations = [x1 y1 1 3; x2 y2 1 3]`
Feed diameter	`pcb.FeedDiameter = W/2`
Set conductor	`pcb.Conductor = metal("Copper")`
Add vias	`pcb.ViaLocations = [x y topLayer botLayer]`
Visualize	`show(pcb)`
Layout view	`layout(pcb)`
Boolean union	`shape = s1 + s2`
Boolean subtract	`shape = s1 - s2`
Boolean intersect	`shape = s1 & s2`

pcbComponent Anatomy

pcbComponent is the universal container for custom RF PCB structures.

Minimal 2-Layer Microstrip

pcb = pcbComponent;
substrate = dielectric("FR4");
substrate.Thickness = 1.6e-3;

signal = traceRectangular(Length=20e-3, Width=3e-3);
ground = traceRectangular(Length=30e-3, Width=20e-3);

pcb.Layers = {signal, substrate, ground};
pcb.BoardShape = ground;
pcb.BoardThickness = substrate.Thickness;
pcb.Conductor = metal("Copper");
pcb.FeedDiameter = 1.5e-3;
pcb.FeedLocations = [-10e-3 0 1 3; 10e-3 0 1 3];
show(pcb);

5-Layer Stripline Structure

pcb = pcbComponent;
sub = dielectric(Name="FR4", EpsilonR=4.4, LossTangent=0.02, Thickness=0.8e-3);

topGnd = traceRectangular(Length=40e-3, Width=20e-3);
signal = traceRectangular(Length=30e-3, Width=2e-3);
botGnd = traceRectangular(Length=40e-3, Width=20e-3);

pcb.BoardThickness = 2 * sub.Thickness;          % Set BEFORE Layers
pcb.Layers = {topGnd, sub, signal, sub, botGnd};
pcb.BoardShape = topGnd;
pcb.Conductor = metal("Copper");
pcb.FeedLocations = [-15e-3 0 3 1; 15e-3 0 3 5];
pcb.FeedDiameter = 1e-3;
show(pcb);

Key Properties

Property	Format	Description
`Layers`	Cell array	Alternating: metal shape, dielectric, metal shape, ...
`BoardShape`	Shape object	Outer boundary of the PCB
`BoardThickness`	Scalar (m)	Must equal sum of dielectric thicknesses
`FeedLocations`	N×4 matrix	`[x, y, signalLayer, groundLayer]` per port
`FeedDiameter`	Scalar (m)	Diameter of feed via/probe
`ViaLocations`	M×4 matrix	`[x, y, topLayer, bottomLayer]` per via
`ViaDiameter`	Scalar (m)	Via barrel diameter
`FeedViaModel`	String	`'strip'`, `'square'`, `'octagon'`, `'hexagon'`
`Conductor`	metal object	Conductor for all metal layers
`SolverType`	String	`'MoM'` or `'FEM'`

Shape Primitives

Rectangular Traces

rect = traceRectangular(Length=20e-3, Width=5e-3, Center=[0 0]);

Line Traces (multi-segment with bends)

tl = traceLine;
tl.Length = [10 5*sqrt(2) 10]*1e-3;
tl.Angle = [0 45 0];
tl.Width = 3e-3;
tl.Corner = 1;          % 1 = Miter, 2 = Smooth (default: Sharp)
show(tl);

Point-Defined Traces

tp = tracePoint;
tp.TracePoints = [0 0; 10e-3 0; 15e-3 5e-3; 25e-3 5e-3];
tp.Width = 2e-3;
tp.Corner = 2;          % 2 = Smooth

Spiral Traces

sp = traceSpiral;
sp.NumTurns = 3;
sp.InnerDiameter = 4e-3;
sp.Spacing = 0.5e-3;
sp.TraceWidth = 0.5e-3;
show(sp);

Tapered Traces

tt = traceTapered;
tt.Length = 10e-3;
tt.InputWidth = 1e-3;
tt.OutputWidth = 3e-3;

Bends

Bend Width is a 2-element vector [w1 w2] for the two arms:

bc = bendCurved;
bc.Width = [2e-3 2e-3];
bc.CurveRadius = 5e-3;

bm = bendMitered;
bm.Width = [2e-3 2e-3];

br = bendRightAngle;
br.Width = [2e-3 2e-3];

U-Bends

U-bend Width is a 3-element vector [arm1 bottom arm2]:

uc = ubendCurved;
uc.Width = [2e-3 2e-3 2e-3];
uc.CurveRadius = 3e-3;

um = ubendMitered;
um.Width = [2e-3 2e-3 2e-3];

Other Shapes

d = delta;
d.OuterRadius = 5e-3;                           % Triangle/delta

db = dumbbell;
db.SideLength = 6e-3;                           % Head size (square Type, default)
db.ArmLength = 10e-3;
db.ArmWidth = 0.5e-3;                           % Dumbbell (for DGS)
% Note: Type='Square' uses SideLength; Type='Circle' uses Diameter

rt = racetrack;
rt.Length = 15e-3;
rt.Width = 5e-3;                                % Racetrack

rd = radial;
rd.OuterRadius = 5e-3;
rd.Angle = 60;                                  % Radial sector

ar = ringAnnular;
ar.InnerRadius = 1e-3;
ar.Width = 4e-3;                                % Annular ring (InnerRadius must be > 0)

sr = splitRing;
sr.RingDiameter = 10e-3;
sr.TraceWidth = 0.5e-3;
sr.SplitGap = 0.5e-3;                           % Split ring resonator

Boolean Operations

Combine shapes using operators to build complex geometries.

Union (+)

left = traceRectangular(Length=10e-3, Width=5e-3, Center=[-5e-3 0]);
right = traceRectangular(Length=10e-3, Width=5e-3, Center=[5e-3 0]);
combined = left + right;
show(combined);

Subtraction (-)

Create slots, gaps, or etched patterns:

base = traceRectangular(Length=20e-3, Width=10e-3);
slot = traceRectangular(Length=15e-3, Width=1e-3);
slotted = base - slot;
show(slotted);

Intersection (&)

ring = ringAnnular;
ring.InnerRadius = 1e-3;
ring.Width = 9e-3;
rect = traceRectangular(Length=15e-3, Width=15e-3);
clipped = ring & rect;

Complex Example: U-CSRR Filter

% Create feeding microstrip
ZA = traceRectangular(Length=4e-3, Width=4e-3, Center=[-7e-3 0]);
Cell = traceRectangular(Length=5e-3, Width=5e-3, Center=[-2.5e-3 0]);
LeftSection = ZA + Cell;

% Create slots using traceLine
s1 = traceLine(StartPoint=[-2.5e-3-0.1e-3, -1.9e-3], ...
    Angle=[-180 -270 0], Length=[1.75e-3 3.8e-3 1.75e-3], Width=0.2e-3);
s2 = traceLine(StartPoint=[-2.5e-3+0.1e-3, -1.9e-3], ...
    Angle=[0 90 180], Length=[1.75e-3 3.8e-3 1.75e-3], Width=0.2e-3);

% Subtract slots from base
LeftSection = LeftSection - s1 - s2;

% Mirror for right section
RightSection = copy(LeftSection);
RightSection = mirrorY(RightSection);

% Complete filter
filter = LeftSection + RightSection;
show(filter);

Feed Placement

FeedLocations Format

Each row: [x, y, signalLayerIndex, groundLayerIndex]

Layer indices are odd numbers (1, 3, 5, ...) for metal layers in the Layers cell array
Layer 1 = first metal (top), Layer 3 = second metal, etc.

% 2-port microstrip (signal on layer 1, ground on layer 3)
pcb.FeedLocations = [-10e-3 0 1 3;    % Port 1: left edge
                      10e-3 0 1 3];    % Port 2: right edge

4-Port Coupled Trace

pcb.FeedLocations = [0 0 1 3;         % Port 1
                     40e-3 0 1 3;      % Port 2
                     40e-3 -5e-3 1 3;  % Port 3
                     0 -5e-3 1 3];     % Port 4

Feed Diameter

pcb.FeedDiameter = traceWidth / 2;  % Must fit within the trace

Internal Ports (for lumped elements)

Define extra feed locations for internal connections to lumped components (see matlab-integrate-pcb-circuit skill for pcbElement with PortNumber/PortValue).

DGS — Defected Ground Structures

Etch patterns into the ground plane using the dgs method:

ms = microstripLine;
ms.Length = 20e-3;
ms.Width = 3e-3;

% Create a dumbbell DGS under the trace
dgsShape = dumbbell;
dgsShape.SideLength = 4e-3;       % Head size (default Type='Square')
dgsShape.ArmLength = 8e-3;
dgsShape.ArmWidth = 0.5e-3;
ms = dgs(ms, {dgsShape});   % Must capture return value — does not modify in place
show(ms);
memoryEstimate(ms, 10e9, 'RetainMesh', true);  % Check mesh before solving
sp = sparameters(ms, linspace(1e9, 10e9, 51), 'SweepOption', 'interp');
rfplot(sp);

DGS adds bandstop characteristics and can improve coupler directivity or filter rejection.

Shielded Enclosures

Add a conductive lid for shielded analysis:

pcb = pcbComponent;
% ... set up layers ...
pcb.IsShielded = true;   % Adds PEC enclosure walls and lid
show(pcb);

For filter-in-enclosure problems, shielding affects resonant frequencies and coupling.

Shape Manipulation

shape = translate(shape, [dx, dy, 0]);  % Translate
shape = rotateZ(shape, angle);          % Rotate about z-axis (degrees)
shape = rotateX(shape, angle);          % Rotate about x-axis
shape = mirrorX(shape);                 % Mirror about x-axis
shape = mirrorY(shape);                 % Mirror about y-axis
shapeCopy = copy(shape);                % Deep copy
shape = scale(shape, factor);           % Uniform scaling
a = area(shape);                        % Shape area (m²)

For catalog objects, extract shapes by layer with shapes():

s = shapes(obj);              % Struct of shapes by layer name
boardArea = area(s.GroundPlane);

For pcbComponent, shapes are in Layers and BoardShape:

boardArea = area(pcb.BoardShape);

Discovering Available Methods

Use methods(obj) to list all available operations on any object:

methods(pcb)                  % List all pcbComponent methods
methods(traceRectangular)     % List all shape methods

Visualization

show(pcb);          % 3-D structure view
layout(pcb);        % Top-down layout with feeds and vias
mesh(pcb);          % Mesh visualization
info(pcb);          % Print structure summary

Advanced Feed Setup (FeedDefinitions API)

By default, pcbComponent uses FeedLocations (XY coordinates + layer) for simple probe feeds. For advanced feed types — coaxial, edge, delta-gap, finite-gap — switch to the FeedDefinitions API:

pcb = pcbComponent;
pcb.FeedFormat = 'FeedDefinitions';     % Enable FeedDefinitions mode

Feed Types

Feed Type	Use When	Key Properties
`ProbeFeed`	Vertical via probe (patch antennas)	`SignalLocations`, `SignalLayers`, `GroundLayers`, `ViaDiameter`, `ViaModel`
`CoaxialFeed`	Probe with explicit pad/antipad geometry	`PadShape`, `AntipadShape`, `SignalLayers`, `GroundLayers`
`EdgeFeed`	Stripline-style edge excitation	`SignalLocations`, `SignalLayers`, `GroundLayers`, `SignalWidths`
`DeltaGapFeed`	Internal port with current direction	`SignalLocations`, `SignalLayers`, `SignalWidths`, `CurrentDirection`
`FiniteGapFeed`	Internal gap port (signal + ground)	`SignalLocations`, `GroundLocations`, `SignalLayers`, `SignalWidths`
`ArbitraryFiniteGapFeed`	Coplanar port with full control	`SignalLocations`, `GroundLocations`, `SignalWidths`, `GroundWidths`, `SignalLayers`, `GroundLayers`

ProbeFeed (Most Common)

f = ProbeFeed('SignalLocations', [-0.0187, 0], ...
    'SignalLayers', 1, 'GroundLayers', 3, ...
    'ViaDiameter', 1e-3, 'ViaModel', 'square');
pcb.FeedDefinitions = f;

EdgeFeed (Stripline Structures)

For 5-layer stripline structures with signal on layer 3 and ground on layers 1 and 5:

f1 = EdgeFeed('SignalLocations', feed1_xy, 'SignalLayers', 3, ...
    'GroundLayers', [1; 5], 'SignalWidths', trace_width);
f2 = EdgeFeed('SignalLocations', feed2_xy, 'SignalLayers', 3, ...
    'GroundLayers', [1; 5], 'SignalWidths', trace_width);
pcb.FeedDefinitions = [f1, f2];

CoaxialFeed (Custom Pad/Antipad Geometry)

pad = antenna.Circle('Radius', 0.5e-3);
antipad = antenna.Circle('Radius', 1e-3);
f = CoaxialFeed('PadShape', pad, 'AntipadShape', antipad, ...
    'SignalLayers', 1, 'GroundLayers', 3);
pcb.FeedDefinitions = f;

DeltaGapFeed (Internal Ports)

f = DeltaGapFeed('SignalLocations', [x, y], 'SignalLayers', 1, ...
    'SignalWidths', 0.5e-3, 'CurrentDirection', [0, 1]);
pcb.FeedDefinitions(end+1) = f;     % Append to existing feeds

Multiple Feeds

Build feed arrays by concatenation or append:

pcb.FeedDefinitions = [f1, f2];          % Row array at once
pcb.FeedDefinitions(end+1) = f3;         % Append incrementally

Shape Primitives Reference

For the full catalog of all shape primitives (traces, bends, curves, rings, special shapes) with properties and common operations, see references/shape-primitives.md.

Pitfalls

Feed outside metal: The feed circle (FeedDiameter) must fit entirely within the metal trace at the feed location. Inset at least FeedDiameter/2 from any trace edge. Failing this causes solver errors.
BoardThickness mismatch — set before Layers: BoardThickness must exactly equal the sum of all dielectric layer thicknesses in Layers. The Layers setter validates against the current BoardThickness, so set BoardThickness before Layers when the total differs from the default (1.6 mm). Setting Layers first with a non-default total causes an error.
Layer indexing: Metal layers are odd-indexed (1, 3, 5, ...) in the Layers cell array. Dielectrics are even-indexed (2, 4, ...). FeedLocations references metal layer indices only.
Boolean operation order: Subtraction is order-dependent (A - B ≠ B - A). The first operand defines the base; the second is removed from it.
Shape overlap for union: Shapes must overlap or touch for + to produce a connected geometry. Disjoint shapes create multi-body structures which may confuse the solver.
FeedViaModel for stripline: For 5-layer (stripline) structures, set FeedViaModel to control the feed via shape connecting the internal signal layer to the external port reference.
Corner property is integer-valued: Set Corner using integers: 1 = Miter, 2 = Smooth (default is Sharp). String values like "Miter" cause errors.
DGS: capture return value + use cell array: dgs does not modify the object in place — you must capture the output: ms = dgs(ms, {dgsShape}). Also pass shapes in a cell array, not bare: {dgsShape}, not dgsShape.
IsShielded auto-switches to FEM: Setting pcb.IsShielded = true automatically changes SolverType to 'FEM'. This is expected but makes the solve significantly slower.
Use rotateZ, not rotate, for z-axis rotation: rotate(shape, angle) requires 4 arguments (angle + two 3D points defining the axis). For simple z-rotation use rotateZ(shape, angle). Similarly rotateX and rotateY for other axes.
FeedFormat is exclusive. Setting FeedFormat = 'FeedDefinitions' disables FeedLocations. You cannot mix both modes — choose one or the other.
GroundLayers as column vector for multi-ground. For stripline structures with ground on both sides, pass GroundLayers as a column vector: [1; 5], not [1, 5].
Each dielectric in Layers must be a single-layer object: Do NOT use a multi-layer dielectric (one with vector Thickness/EpsilonR) as a single entry in the Layers cell array. Each dielectric layer must be its own separate dielectric object with scalar properties. For a 5-layer stack: pcb.Layers = {metal1, diel1, metal2, diel2, metal3} where each diel has scalar Thickness.

matlab-manage-pcb-material — Defining dielectric and metal for layers
matlab-analyze-em — Analyzing the assembled structure
matlab-design-pcb-filter — Filters using custom pcbComponent geometry
matlab-integrate-pcb-circuit — Connecting pcbComponents together

Files

ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
LICENSELicence file added by AutoGineer1.4 KiB
SKILL.md17.2 KiB
manifest.yaml482 B
references/shape-primitives.md3.1 KiB

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

MathWorks

Publisher

MathWorks (Official)

Source

matlab/matlab-agentic-toolkit · skills-catalog/rf-and-mixed-signal/matlab-assemble-pcb-layout · commit 2a7f215

Licence

BSD 2-Clause License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE.md)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-assemble-pcb-layout.zip