🖼️ Panel

📌 What

A plain mounting panel that fits into the HomeRacker scaffold system. Panels attach to vertical and horizontal supports via lockpin holes and can be used as-is (blank panels) or as a base for custom cutouts (keystone jacks, switches, displays, etc.).

🤔 Why

• Universal base: A generic panel module that any specialized panel (keystone, frontpanel, side panel) can build upon — no distinction between front/side at the lib level.
• Two integration types:
  • Inter-Fit: Inset panel for a flush fit between support bars. Each panel can be removed independently.
  • Full Cover: Overlap panel covering supports and connectors for a clean aesthetic. Must be integrated during scaffold assembly.
• Scalable: Supports arbitrary grid sizes (min 2×2 units). Panels larger than 2 units automatically get additional mount surfaces for rigidity.
• Per-side control: Each edge’s mount surface can be enabled/disabled independently (north/south/east/west), and corner mounts can be toggled between full-height lockpin engagement and contour-only mode.

🔧 How

Open parts/panel.scad in OpenSCAD and use the Customizer panel.

📸 Catalog

Part	Preview
Panel (Inter-Fit)
Panel (Full Cover)
Rack Panel (10”)
Rack Panel (19”)
Split Connector
Split Lock Pin

To generate or refresh the renders (full F6 renders via scadm export-png):

scadm export-png models/panel/parts/panel.scad
scadm export-png models/panel/parts/rackpanel.scad
scadm export-png models/panel/parts/split_connector.scad
scadm export-png models/panel/parts/split_lockpin.scad

Panel Variants

Default (all mounts enabled)

Inter-Fit	Full Cover

Contour Corners (corner_mounts = false)

Wherever a mount surface is disabled (corners or edges), the panel shows a contour instead — a short wall at BASE_STRENGTH height without lockpin holes. The contour provides added stability and keeps the panel opaque (no gaps), while staying short enough to not block any attachments on the HR scaffold.

When to use corner mounts:

Corner mounts occupy the lockpin holes normally used by supports and connectors. This matters when two panels share a 90° edge of the rack — one panel’s corner mount blocks the lockpin hole needed by the other. For panels > 3×3 units, leaving corners disabled (contour only) is recommended as the mount surfaces alone provide sufficient engagement and it’s easier to first build the scaffold and afterwards add panels to it.

For smaller panels (≤ 3 units on one axis), corner mounts become valuable: a 3-unit side has only 1 lockpin hole on its mount surface, and panels < 3 units have no mount surfaces at all. Corner mounts (combined with extended lockpins — neck, tail, or both variants) let these panels use connector lockpin positions that would otherwise be inaccessible.

Inter-Fit	Full Cover

Partial Mounts (south + west disabled)

Shows the difference in wall height between panel types when mount surfaces are disabled:

• Inter-Fit: disabled sides get full-height walls (same as mount height) to maintain the panel contour.
• Full Cover: disabled sides get short 2mm walls only, keeping the area clear for attachments in the HR scaffold.

Inter-Fit	Full Cover

Minimal Size (2×2)

The smallest possible panel — only corner mounts, no mount surfaces (they require > 2 units). Disabling corner_mounts on a 2×2 panel makes the panel non-mountable.

Inter-Fit	Full Cover

🔩 Rack Panel

A standard 10”/19” rack-compatible panel with configurable bore patterns. Open parts/rackpanel.scad in OpenSCAD.

Parameters

Bore Modes

💪 Stiffening: depth vs back brace

Two independent ways to make a panel stiffer — combine them for the most rigid result:

• panel_depth (Strong, 4mm) — thickens the whole skin. Because panels print face-down, depth is the vertical (Z) print direction, so the slicer fills the added volume with sparse gyroid infill: a deep panel becomes a cheap sandwich/I-beam that resists broad bending well. Stiffness scales with your slicer’s infill settings, not the model.
• back_brace — a triangulated truss grown onto the back, protruding to the split-knuckle plane (so it stays flush with split connectors) while never touching the front face or its chamfer. Each cell carries a diagonal whose direction alternates in a checkerboard (a Warren/zigzag lattice), so it resists racking/torsion equally both ways instead of favouring one handedness — the kind of load gyroid infill handles poorly. On split panels each half gets its own framed sub-brace, mirrored about the centerline, with a clear gap for the connector. Bands scale with panel height so triangles stay a consistent size; columns auto-size for roughly square cells.

Rules of thumb: small panels rarely need either; wide (19”) or tall multi-U panels benefit most from the brace; back_brace + Minimal bore mode is the lightest stiff combo. The brace’s solid ribs are not free — dense density on a large panel can use more plastic than simply going to Strong panel_depth (which is mostly sparse infill), so prefer regular unless you need the extra rigidity. A panel already as deep as the knuckle plane gets no brace (it would not protrude).

See stiffen-rack-panels-with-truss-grid for the rationale, and lib/truss.scad for the generic lattice module.

🧪 Real-world print test (19” 1U)

Four 19” 1U split panels printed back-to-back on a Bambu Lab X1C with identical HomeRacker default settings (3 walls, Arachne, 15 % gyroid, Bambu PLA Matte Charcoal), then hand-loaded in two ways: shear (twisting the center) and bending (flexing along the split seam).

Takeaways:

• back_brace carries the torsion/shear load — both braced panels (#3, #4) clearly beat the unbraced ones at twisting.
• Strong (4 mm) panel_depth adds broad bending stiffness cheaply (sparse infill), and combined with the brace gives the best all-round result for only ~2 g over the brace-only panel.
• The strong split connector was removed. Widening the hinge knuckles to a full base unit (specimen #2’s original print) actually made the seam flex more and added material without improving stiffness, so the option no longer exists — the slim connector is now the only one. See stiffen-rack-panels-with-truss-grid.

Best value: 4 mm panel_depth + back_brace (slim connector).

Variants

Default

1U	2U

All (Full)

1U	2U

Minimal

1U	2U	3U

Back Brace (viewed from behind)

The triangulated stiffener grows on the panel back, flush with the split-knuckle plane — see Stiffening. Each panel/half carries its own framed field; on a split panel the two halves mirror about the centerline with a clear gap for the connector and lock pin.

10” (regular)	10” (dense)	19” split

Module Architecture

rackpanel          → orchestrator: bore mode logic, chamfering (edge_mask)
└─ rackpanel_stack → pure stacker: one zcopies of rackpanel_1u
   └─ rackpanel_1u → single 1U body with bore subtraction (no chamfer)
      └─ bores_1u  → 1–3 evenly spaced bores per unit
└─ bores_minimal   → 1–2 bores (top + bottom unit centers) for MINIMAL mode

See lib/rackpanel.scad for implementation.

🧩 Building on rack panels (children + usable frame)

rackpanel is BOSL2-attachable and passes children through on the Full, Left-half, and Right-half views, so a downstream model can add or subtract geometry against the panel face — e.g. drop in keystone jacks (each cuts its own pocket and leaves the jack body) with a diff() pass:

include <models/panel/lib/rackpanel.scad>
include <models/panel/lib/split.scad>
include <models/keystone/lib/keystone.scad>

diff("keystone")
rackpanel(split_mode=HR_RP_SPLIT_HALF, view_mode=HR_RP_VIEW_HALF_LEFT)
  align(FRONT, inside=true)
    right(get_rackpanel_usable_x(STD_WIDTH_10INCH, HR_RP_SPLIT_HALF, HR_RP_VIEW_HALF_LEFT))
      keystone_full(panel_depth=get_ks_depth_outer());

Children are emitted outside the internal tag_scope, so a tag("keystone") cutter survives to the enclosing diff(). keystone_full() already tags its own pocket as "keystone", so call it bare — wrapping it in another tag("keystone") would turn the whole jack into a cutter (a hole, no body). A plain cuboid cutter, by contrast, does need the explicit tag("keystone"). The assembled/exploded views are preview-only and do not take children.

Usable band — a magenta marker the exact size of the cutout-safe band, attached to the panel back face so any overlap with a mount column is obvious. The split halves leave the central split-connector knuckle uncovered.

Full panel	Split panel (assembled)

Keystone jacks — a real keystone_full jack (shown in white via debug_colors) cut into a strong (4 mm) braced panel. Front shows the installed socket; back shows the jack body protruding alongside the truss brace.

	Front	Back
Full panel
Split half

Two helper functions describe the cutout-safe band (the panel face minus the rackmount mount-surface columns and slide-in clearance):

A split-aware consumer distributes its content left/right itself and calls rackpanel once per half; the library does not split content for you. See rackpanel-usable-frame-helpers.

✂️ Split Panels

A 19” rack panel (482.6mm) is wider than most printer beds. Split mode divides the panel along its vertical centerline into two halves that print separately and join into a rigid panel — no glue, no fasteners beyond a single lock pin.

How it works

• Split connector — a hinge-like column of interlocking knuckles is grown onto the facing edge of each half (via split_connector). The two halves interleave like the leaves of a door hinge. Each height unit has four knuckles: a lock knuckle (a full HomeRacker base unit with a tension lock-pin socket) at each end, and two shorter middle knuckles (plain 4mm square holes) sharing the space between them. The layout is point-symmetric — both halves always own exactly two knuckles and the connector is identical whichever way you rotate it, so multi-unit panels simply stack identical units straight up.
• Split lock pin — the split_lockpin part threads vertically down the aligned knuckle bores like a hinge rod and locks the joint. It reuses the standard lock pin’s tension grip as its single lock element, seated in the lock knuckle at one extreme end of the pin; a plain shaft (with a finished chamfered end) runs from the grip up through every remaining knuckle. Multi-unit pins keep the single grip and just extend the shaft.

Print & assembly

1. Set split_mode = 1 (Half) and print each half — use view_mode = 1 (Left) and view_mode = 2 (Right). view_mode = 0 (Assembled) previews the finished panel with the lock pin seated, and view_mode = 3 (Exploded) shows how the two halves and the pin fit together — neither is a print layout. The hinge knuckles are generated automatically as part of each half; parts/split_connector.scad exposes the bare connector standalone for preview and inspection.
2. Print the matching Split Lock Pin (parts/split_lockpin.scad) at the same height_units.
3. Interleave the two halves’ hinge knuckles and slide the lock pin down through the aligned bores until it seats.

⚠️ Warping & thick parts: Thick panels printed on their edge (Strong 4 mm panel_depth) warp more easily — the effect is worse on textured PEI plates and toward the bed edges, where heating is less even. A warped split seam can stop the lock pin from inserting. Anecdote: on a Bambu Lab X1C (256 mm bed) with Bambu PLA Matte (Charcoal) and typical HomeRacker settings (3 walls, 15 % gyroid, Arachne wall generation), a 4 mm panel_depth half warped near the bed edge and the pin would not seat. Fix: print one part at a time, laid diagonally for extra edge clearance. Larger printers are less likely to hit this.

Parameters

Split Connector (parts/split_connector.scad)

Split Lock Pin (parts/split_lockpin.scad)

Variants

Split Panel (2U, 19”)	Split Connector (1U)	Lock Pin (1U)	Lock Pin (2U)

To generate or refresh the renders (full F6 renders via scadm export-png):

scadm export-png models/panel/parts/split_connector.scad
scadm export-png models/panel/parts/split_lockpin.scad
scadm export-png models/panel/parts/split_lockpin.scad -D height_units=2 --output models/panel/parts/renders/split_lockpin_2u.png
scadm export-png models/panel/parts/rackpanel.scad -D panel_width_type=2 -D height_units=2 -D split_mode=1 -D view_mode=3 --output models/panel/parts/renders/rackpanel_split_2u_19inch.png

Module Architecture

split_connector   → 4-knuckle hinge column per unit (lock + 2 middle + lock), stacked straight up
└─ knuckle        → single knuckle: lock (tension socket) or middle (4mm square bore)
split_lockpin     → hinge-rod pin: single tension grip at one end + plain shaft through the rest
├─ split_lockpin_grip  → tension element (flex-slit grip) that seats in the bottom lock knuckle
└─ split_lockpin_shaft → plain shaft with a filleted + chamfered outer end

See lib/split.scad for implementation.

🧭 Anchoring Behavior

The panel() module is fully BOSL2-attachable. Its bounding box encompasses all mount surfaces — not the Full Cover base plate. This means anchors align with the functional mounting geometry, making it straightforward to position child components (e.g. keystone jacks, switches) relative to the actual panel area.

Inter-Fit Panels

Anchors align directly with the panel’s base plate + mount surfaces. The bounding box extends BASE_STRENGTH beyond the base plate on each side that has support mount plates (i.e. when units > 2 on that axis). The extension is always symmetric — disabling individual mount surfaces does not shrink or shift the bounding box.

Full Cover Panels

On Full Cover panels, the overlap base plate is larger than the mount surface bounding box. Anchors intentionally do not align with the Full Cover plate edges — they align with the mount plate boundaries instead. This is the correct behavior because:

• Child components (cutouts, jacks) should align with the structural panel area, not the cosmetic overlap.
• Using align(BACK+BOTTOM) on a Full Cover panel positions the child at the mount plate’s back edge — exactly where the support bar sits — maximizing usable space.

💡 Example: A keystone jack attached with align(BACK,BOTTOM,inside=true) perfectly aligns with the support plate edge, making optimal use of the panel’s vertical space without intersecting the scaffold structure.

Stable Anchors

Anchors remain fixed regardless of which mount surfaces are enabled or disabled. Disabling a mount plate (e.g. mount_west=false) removes the plate geometry but does not shift the bounding box or anchor positions. This ensures children attached via align() stay in a predictable position — aligned with the support bar boundary — even when mount plates are selectively disabled.

📚 References

• HomeRacker core