Matlab Assemble Pcb Layout

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-txline
• 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.

10. 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.

11. FeedFormat is exclusive. Setting FeedFormat = 'FeedDefinitions' disables FeedLocations. You cannot mix both modes — choose one or the other.

12. 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].

13. 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.

Related Skills

• 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

----

Copyright 2026 The MathWorks, Inc.