Skip to the content
4 layers83.4 × 38.7 mmManifold, the printed circuit board in 3D

Companion KiCad project for "Manifold", an Arduino Nano inspired (pinout/ form-factor only — not an official Arduino product, and not Arduino-IDE compatible) 12V-powered board built from automotive/high-temp-rated parts…

Size
83.4 × 38.7 mm
Copper layers
4
Thickness
1.6 mm
Parts
30
Nets
47
Pads
186
Tracks, vias
720, 67
Pours
2
Routed
Yes
KiCad
KiCad 10.0 (file 20260206)
Created
14 Aug 2026
Updated
27 Sep 2026

Overview

Manifold is an open-source printed circuit board by jessiepullaro414, from the jessiepullaro414/Manifold repository on GitHub, published under the MIT licence. It is a 4-layer board of 83.4 × 38.7 mm with 30 parts on 47 nets, routed with 720 tracks and 67 vias.

Its parts include 12 capacitors, 4 ICs, 3 resistors, 3 connectors and 2 inductors.

README

README.md

Manifold — KiCad schematic + PCB

Companion KiCad project for "Manifold", an Arduino Nano inspired (pinout/ form-factor only — not an official Arduino product, and not Arduino-IDE compatible) 12V-powered board built from automotive/high-temp-rated parts for engine-bay environments.

Opening it

Open Manifold.kicad_pro in KiCad 6, 7, or 8. Everything the schematic needs (all symbols) is embedded in Manifold.kicad_sch itself — no external symbol libraries required to open and view it.

Both the schematic and Manifold.kicad_pcb are kept in KiCad's current native format (not just an older-but-compatible one) — see "File format" below.

J1's footprint (TE AMPSEAL 776180-1) lives in this project too — fp-lib-table registers it under the library nickname TE_AMPSEAL_776180-1, pointing at footprints/TE_AMPSEAL_776180-1.pretty/ via ${KIPRJMOD} (KiCad's "this project's folder" variable) — so it resolves automatically for anyone who opens this project, without depending on where it was originally downloaded to.

Same pattern on the schematic side: sym-lib-table registers this project's own custom parts under the nickname Manifold, pointing at Manifold.kicad_sym (both regenerated by build_schematic.py - don't hand-edit either). The schematic still embeds every symbol inline too (so it opens/nets fine even without this), but a real external library file is what lets KiCad's own "Add Symbol" browser find Manifold:* parts, and is what a from-scratch kicad-cli sch erc needs to not flag every single part as "library not included in configuration".

Building it

build.py runs the whole real pipeline in order — schematic generation, PCB placement, autorouting, DRC — the same four scripts described in "Routing it" and "How the schematic is built" below, just chained together:

text
python build.py                 # full pipeline
python build.py --skip-route    # skip the slow FreeRouting pass

Checking it

run_drc.py runs kicad-cli pcb drc against Manifold.kicad_pcb (or any other .kicad_pcb passed as an argument) and prints a readable report from the JSON it produces — unconnected-item count (expected on this unrouted board) plus every other violation type, grouped, with the actual offending items and positions, not just per-type counts. build_pcb.py also runs DRC as its own last step, but only prints counts; reach for this when you need the detail behind one of those counts.

text
python run_drc.py
python run_drc.py path/to/other.kicad_pcb

kicad-cli sch erc Manifold.kicad_sch is the schematic-side equivalent. It went from 388 violations to 4 during a real triage pass (not just a recount) - see "Rotated-footprint pad shapes" below and [[kicad-file-generation-gotchas]] for the technical detail on each fix:

  • 259 endpoint_off_grid - every symbol placement now snaps to KiCad's 0.05in (1.27mm) schematic grid.
  • 70 lib_symbol_issues - added a real Manifold.kicad_sym + sym-lib-table entry (this project's custom parts were only ever embedded inline in the schematic before, with no external library file backing them - fine for KiCad to open/net-list, not fine for its "library not found" check or for inserting a fresh instance from the symbol browser).
  • 25 label_dangling + 25 no_connect_connected - U1's 25 spare MCU pins now get a real no-connect flag instead of a same-named, inherently one-off local label.
  • 3 isolated_pin_label - same fix, applied to 3 individually-unused pins elsewhere (U2's PG, U4's NC, J2's NC) via a new ('nc',) place() mode.
  • 1 pin_to_pin - J1's +5V/+3V3 pins were typed power_out (implying the connector generates power), conflicting with U4's real LDO output on the same net - retyped passive (a connector pin exposing a rail isn't a second source of it).

The remaining 4 are genuine, expected ERC characteristics, not bugs - each one is ERC's pin-type-based "is this driven?" check failing to trace through a passive network or off-board source, not a real missing connection:

  • +5V, VDDA, and U2's VIN each show power_pin_not_driven because their real source sits on the far side of an LC filter (L1), a ferrite (L2), or a MOSFET (Q1) - none of which have a power_out-type pin to point to, since ERC doesn't trace continuity through passives.
  • J2's SWCLK shows pin_not_driven because it's genuinely driven off-sheet, by an external debug probe.

If you regenerate and see anything other than these same 4, treat it as a real regression, not baseline noise.

Buck feedback divider - a real bug found in final review

R2/R3 (U2's FB divider) used to be 10k/3.3k, solving TI's own formula (Vout = VREF x (RFBT/RFBB + 1), VREF = 1V nominal per LMR33630-Q1's datasheet Section 8.2.2.3) to ~4.03V, not 5V - a real, roughly-1V-low output, not a rounding nitpick. This mattered because that rail is exposed on J1 as a Nano-compatible +5V pin for external peripherals - anything expecting real 5V plugged into it would have been under-powered or malfunctioned outright, and it ate into U4's LDO dropout margin too.

Fixed by solving for RFBB with RFBT held at 10k: 10k / (5V/1V - 1) = 2.5k, using the nearest standard E96 value, 2.49k - which is suspiciously exactly TI's own worked-example RFBB (24.9k, for their 100k/24.9k 5V divider) scaled down by 10x, suggesting 3.3k was a substitution/typo somewhere rather than a deliberate choice. New value gives ~5.02V.

File format

kiutils (the library both generators use) writes the older v6-era schema by default — version 20211014, generator kiutils, unquoted UUIDs, no generator_version field. KiCad opens that fine, but flags schematics as needing conversion, and that would reappear every time either generator regenerates its file.

Fixed at the source rather than worked around: both generators' last step shells out to kicad-cli sch upgrade / kicad-cli pcb upgrade — KiCad's own real format converter — on the file they just wrote. If kicad-cli isn't found on your machine, the scripts still finish and print a note — the files just won't be pre-upgraded.

The PCB: what's real, what's placeholder, what's routed

build_pcb.py reads the schematic + a fresh kicad-cli netlist export and generates Manifold.kicad_pcb: every part's real footprint (loaded from its actual .kicad_mod file, not reinvented), with every pad assigned the net the schematic says it should have.

What this does NOT do: route copper. Placement gives a compact starting point, but this is a netlist-correct unrouted board — the same state "Update PCB from Schematic" leaves you in before you route it yourself.

Placement is a real 2D bin-pack, not a row of parts. All 27 small parts go through a single skyline bin-packer: it maintains a height profile across the board's full width (fixed by J1 regardless of how tightly the small parts pack — J1 is 20-40x bigger than everything else, so it, not the small parts, sets the real width floor) and places each part wherever it produces the lowest resulting top edge — trying every part both unrotated and rotated 90°, not just a designated subset. Since greedy bin-packing is order-dependent (which part gets considered first changes the whole resulting layout), best_skyline_pack runs it with 5 different orderings (largest-area, longest-side, tallest, widest, largest-perimeter first) and keeps whichever actually produced the shortest board — cheap to do exhaustively for 27 parts, and not something a single fixed heuristic can guarantee on its own. Board is currently ~83×61mm, down from an initial ~142×88mm row-based layout.

Diminishing returns, checked quantitatively, not just eyeballed: after this rewrite, a per-mm-column height profile across the packed region shows almost the entire width already sitting at or near the maximum height — not one big rectangular gap like before, but a tightly-filled, slightly uneven skyline. That's because U1 (the MCU - at the time, still the placeholder LQFP48 footprint; see "U1's pinout" below for why that was wrong and what replaced it) was 10.3×10.3mm — by far the single biggest part — and its own footprint+margin already accounts for most of the packed region's height on its own, regardless of what gets stacked around it. Forcing U1 to place last instead of first (an explicit experiment, not a guess) made the board worse (21.0mm packed height vs. 13.6mm) because all the good low spots were already taken by the time U1 needed one. Clustering the MCU's own decoupling caps (100nF/1uF) physically next to it is genuinely good practice for the real routed board's signal integrity, but in this bounding-box model it wouldn't shrink the board further, since U1's own footprint already sets the height floor no matter which parts sit next to it.

A second real bug, found by comparing against a manual rearrangement: after seeing this layout, the user manually spread the small-parts grid out further in the KiCad GUI and saved the file - reading those exact saved coordinates back out ((at x y angle) per footprint, regex-extracted since kiutils can't re-parse a KiCad-saved file - see gotchas doc) showed their arrangement using ~78mm of width to reach ~10.8mm of height, meaningfully shorter than the script's own ~74.6mm-wide, ~12.2mm-tall result at the time. The packer was handing itself less room than it actually had: pack_width was j1_width - 2*BOARD_MARGIN, reserving a second margin on the right of the small-parts grid on top of the margin baked into board_width's own max(used_w, j1_width) + 2*BOARD_MARGIN formula. Since board width is already going to be at least j1_width + 2*BOARD_MARGIN regardless, giving the packer up to the full j1_width costs nothing as long as it stays within that - fixed by setting pack_width = j1_width outright. A width sweep (72-95mm) confirms j1_width is the actual area-minimizing choice for this part mix, not an arbitrary pick: going wider trims a little more height but grows board width faster than that saves. Board dropped from 83.4×62.4mm to 83.4×61.0mm on this fix alone - free, since the board was already going to be at least that wide.

The manual arrangement still edges out the automatic packer somewhat (~10.8mm vs ~12.2mm content height) - most likely because a human doing this by eye can look at the whole board and backtrack, where the packer commits to each part's position in one greedy left-to-right pass and never revisits it. Closing that remaining gap would need a fundamentally different search (backtracking or exhaustive), not just another ordering heuristic - tried 8 orderings x 11 width targets in a grid search and the result barely moved (60.92mm best vs 61.0mm), confirming this is a real plateau for the current greedy-heuristic family, not a tuning oversight.

This replaced an earlier two-block design (a fixed "actives" column next to a "caps" grid, sized by a pre-computed proportional-area split, with small headers optionally dropped into whatever rectangle the split left over). That design couldn't reach real density: caps are small and uniform and pack far more efficiently per mm² than the actives, so even a "correct" area-proportional width split still left the caps block shorter than the actives column, and the leftover rectangle only fit parts that happened to match its exact shape — real open board space stayed open, which is exactly what got flagged when reviewing a render. A single shared skyline profile lets any part drop into any low spot next to any neighbor, not just its own block's slice, which is what actually closes gaps like that.

A real rotation bug was caught verifying this one. The 90°-CCW local coordinate transform (x,y) → (-y,x) used everywhere rotation was needed — in the packer's own placement math and in the pre-write overlap-check verification, so both sides agreed with each other — turned out to be backwards for KiCad's actual rotation direction ((x,y) → (y,-x)). Because both sides used the same wrong formula, the script's own overlap assertion never caught it — it was internally consistent, just wrong. It surfaced instead as a real, tiny (0.015-0.18mm) pad-to-pad clearance and shorting_items DRC violation between a rotated pin header (J3) and a neighboring IC (U2), where the rotated header's far pads landed almost on top of the IC's pads instead of facing away from it. Confirmed by manually computing where kicad-cli's real DRC said those specific pads actually were, which only matched the (y,-x) transform. This is the reason bugs like this get caught by kicad-cli's real DRC and not just the script's own geometry checks — two internally-consistent code paths agreeing with each other is not the same as either of them being correct.

Three more real bugs were found and fixed while doing this work:

  • Footprint bounding boxes were pad-only, undercounting parts like J1 — a right-angle through-hole connector whose silkscreen/body outline extends well past its pad positions. This produced margins that looked fine on paper but caused real silk_edge_clearance and courtyards_overlap DRC errors at tight spacing. Fixed by including silkscreen graphics (lines, polys, arcs) in the bbox calculation, not just pads — after which margins could go back down to their intended tight values and every clearance error disappeared.
  • Every part showed as "REF**" in DRC reports and the 3D viewer, because only the silkscreen text was being updated (fp.graphicItems), not the separate fp.properties["Reference"]/["Value"] dict that KiCad's own tools (DRC, BOM, 3D view) actually read from. Fixed by setting both.
  • Every reference designator sat dead center on its own part, on top of its own pads (silk_over_copper x58, silk_overlap x35 in kicad-cli pcb drc - see run_drc.py below). Root cause: kiutils' Footprint.properties is a plain {name: value} string dict - it has no field for a property's position, layer, or font, so to_file() can only ever write a bare (property "Reference" "REF") token, discarding whatever real position the source library footprint had. kicad-cli pcb upgrade then fills in the missing fields using KiCad's own built-in default for that property name - Reference defaults to (at 0 0 0) on F.SilkS, i.e. dead center - which is fine on a normally-spaced board but guarantees overlap at this board's 2mm part spacing. (Value/Datasheet/ Description bare properties don't show up as silkscreen violations, because KiCad's defaults for those names are F.Fab/hidden, not visible silkscreen - so this was specifically a Reference-designator problem, not a general "properties are broken" problem.) Fixed by patching the written file's bare (property "Reference" "REF") tokens - exact string replacement, not regex, since the one-line form kiutils writes is exactly known at that point in the script, before pcb upgrade ever touches the file - with a real per-part position (just clear of that part's own bbox, reusing the same footprint_bbox() already used for placement) and a 0.8mm font sized for 2mm part spacing instead of KiCad's normal 1.27mm default. Went from 96 DRC violations to 3 (the remaining 3 are an unrelated lib_footprint_mismatch finding - local footprint copies differing slightly from their library originals, not a silkscreen issue).

Layer stackup: 4 layers

board.layers now declares F.Cu, In1.Cu, In2.Cu, B.Cu (verified present in the generated file after pcb upgrade). In1 as a solid GND pour and In2 as a +5V/+3V3 pour is standard practice for a board with a switching buck regulator on it — shorter return paths, better EMI — and this board already has one, so 4 layers is a sensible default rather than an arbitrary choice. Exact dielectric thickness/material is left at KiCad's defaults; set those in Board Setup if you have fab-specific requirements.

The planes are now real, not just planned. route_board.py's add_and_fill_zones() pours a solid GND zone on In1.Cu and a solid +3V3 zone on In2.Cu (the primary MCU supply rail now that U1 runs entirely on 3.3V — see "The MCU" below; +5V stays a normal routed trace, since it's the lower-current Nano-compatibility rail feeding just J1's +5V pin and the LDO input, not something else on this board depends on for a low-impedance return path the way the buck regulator's GND loop does).

Zones are added AFTER routing, not before — that ordering is load-bearing, not a style choice. The first attempt added the zone outlines in build_pcb.py, before handing the board to FreeRouting, on the theory that its Specctra DSN "plane" mechanism would let the autorouter treat those layers as pre-claimed and route everything else around them. That backfired two different ways:

  1. It made this already-tight board measurably harder to autoroute. A solid zone covering an entire inner layer removes that layer's normal "just drop a via here" flexibility everywhere on the board, not only where the plane's own net actually needs it — and this board has a 0.5mm-pitch 64-pin LQFP and a similarly tight VQFN-12 with very little room to spare already. Runs that reliably hit 0 unrouted nets before zones existed started leaving 1-4 stuck on the same few tight spots (U2's exposed-pad-to-pin connection, some U1-to-J1 nets) with zones present pre-route.
  2. Worse: FreeRouting would report "100% routed" while run_drc.py still found real "missing connection" findings between GND/+3V3 pads (e.g. J1's THT pins) and the zone itself. The router had skipped drawing an explicit trace/via to some pads, assuming the plane would cover them — but the actual fill polygon, computed afterward and cleared around every other net's copper, didn't always reach every such pad. FreeRouting's own self-report and KiCad's real DRC were checking two different things, and only the second one is trustworthy — another instance of this project's running theme that a tool's own "success" claim isn't verification.

The fix: route the whole board as ordinary traces first — the same simple, reliable regime that got 0 unconnected items before any zones ever existed — and only then add the zones as purely additive copper on top of an already-100%-connected board. Any GND/+3V3 trace or via the zone happens to overlap becomes redundant (harmless), not the only connection, so there's no longer any way for a pad to end up "connected only via a plane that doesn't quite reach it." Pad connections are solid (ZONE_CONNECTION_FULL), not thermal-relief spokes, for the same reliability reason — no spoke geometry to fail, and this board isn't hand-soldered at a scale where thermal relief's easier-rework benefit outweighs connection certainty.

One more real bug along the way, a KiCad Python-scripting one, not a design one: filling both zones (different layers) in a single pcbnew process reliably segfaults on the subsequent board.Save() — confirmed directly by isolating each step (adding both zones: fine; filling both: fine; only Save() afterward crashes, every time, only with two different-layer zones present together). One zone filled and saved alone never crashes. Root cause looks like a real threading/state bug in this KiCad build's zone filler under scripting, not something to tune around via zone settings — worked around by doing each zone in its own separate python.exe subprocess (load → add one zone → fill → save), so the second zone's process loads a file that already has the first zone's completed fill baked in, and the two fills are never in memory together.

Branding: the JessiesCars logo on B.SilkS

build_pcb.py places a real vector logo (badge + winged mark) on the back silkscreen, sourced from both.kicad_sym — a bitmap2component-generated schematic symbol (29 polylines, ~1450 points, traced from the real artwork, not anything this script invents). B.SilkS is otherwise completely empty (nothing's mounted on the back), so it's placed in J1's own footprint "shadow" — J1's bbox has a tall lower region below its 3 pad rows (its plastic housing outline) with zero pads or drills in it, genuinely clear space rather than just visually-empty space a THT pad barrel would poke through.

Two coordinate-transform bugs, both caught by literally looking at the render, not by DRC (DRC has no way to know a logo is upside down or backwards — this is a visual-correctness class of bug, not an electrical one):

  1. Symbol space is Y-up, PCB board space is Y-down — the exact same convention gotcha build_schematic.py already documents for placing symbol pins onto the sheet, easy to forget applies here too since both.kicad_sym is also a symbol-space file. Missing this flip put the whole logo upside down on the first attempt.
  2. A back-layer shape's stored coordinates are NOT auto-mirrored by KiCad — only text gets a mirror flag (Justify(mirror=True), see kicad-file-generation-gotchas); a plain polygon's points are used as-is, so artwork authored in normal (front-view) orientation reads backwards once the physical board is flipped over to view the back. Text needs the flag; polygons need their X coordinates negated by hand before placing, since they have no equivalent flag to set.

Both flips are real and both apply together (not either/or) — applying only one produces a result that's wrong in a different, less obviously "just mirrored" way (a 180° rotation, not a clean left-right flip), which is exactly what the first attempt looked like: legible-ish but wrong letters ("CARZ" for "CARS"), not obviously backwards at a glance. Fixed by negating both X and Y before scaling/placing. Verified by rendering the back side (kicad-cli pcb render --side bottom) and reading the actual wordmark, not just checking DRC — DRC-clean and visually-correct are different checks here.

Same gr_poly gotcha as gr_text on the uuid front: kiutils' tstamp field writes an unquoted (tstamp xxxx), not the quoted (uuid "xxxx") a real KiCad-written gr_poly has, and kicad-cli segfaults loading the file without it — patched post-write, same pattern as the Reference-label and credit-text fixes before it.

Routing it

route_board.py routes the board with FreeRouting, the same way most KiCad users do it manually: export a Specctra .dsn, autoroute it, import the resulting .ses back, then pour the GND/+3V3 zones on top. Four steps, run headless:

text
python route_board.py
python run_drc.py
  1. Export — pcbnew.ExportSpecctraDSN(), called through KiCad's own bundled Python (C:\Program Files\KiCad\10.0\bin\python.exe, which has the real pcbnew module — different from the Python that runs the rest of this project's scripts). This is KiCad's real, tested exporter, not a reimplementation — kicad-cli doesn't expose DSN export at all (checked; its pcb export subcommand list has no dsn/specctra option), but the underlying scripting API does, and it's fully headless.
  2. Route — java -jar tools/freerouting-2.2.4.jar -de ... -do ... -mp 60 -oit 0 --gui.enabled=false. Requires Java (this project uses Eclipse Temurin 25 JRE) and the FreeRouting jar (57.8MB, not committed — see below).
  3. Import — pcbnew.ImportSpecctraSES(), same bundled-Python mechanism, writes the routed tracks/vias back into Manifold.kicad_pcb and saves it.
  4. Pour zones — GND on In1.Cu, +3V3 on In2.Cu, added and filled after routing (not before — see "Layer stackup" above for why that ordering matters and the real bugs skipping it caused), each in its own separate python.exe subprocess (also explained above — filling both in one process segfaults on save).

Setup (one-time): install a JRE, and download freerouting-2.2.4.jar into tools/. The jar, not the installer — FreeRouting's own docs specify the jar for headless/CLI use; the installers are for interactive use only.

Current result: FreeRouting routes all 47 nets (103 pin-to-pin connections, after U1's real 64-pin pinout replaced the old unwired placeholder — see "U1's pinout" below) in 15-30 seconds — run_drc.py confirms 0 unconnected items, same handful of pre-existing lib_footprint_mismatch findings as before, nothing routing-related.

The autorouter isn't perfectly deterministic run-to-run — occasionally it'll settle for 1-4 nets unrouted and stop (its own plateau-detection gives up when a pass makes no further progress), rather than reaching 0 every single time. When that happens, just re-run python route_board.py from a fresh python build_pcb.py (not on top of the partially-routed board — re-routing incrementally on top of a stuck partial state hits the same plateau again, since nothing about the board actually changed). A second full-from-scratch attempt has reliably reached 0 unrouted so far.

The inner layers are real planes now, not general routing layers — see "Layer stackup" above for the GND/+3V3 zone pours and the real bugs (a routing-reliability regression and a scripting segfault) that showed up getting there.

U1 is fully wired now — no exceptions. Earlier revisions of this board left every one of U1's pads without a net, because its schematic pin numbers were an unverified generic placeholder that didn't reflect any real chip's actual pinout — wiring them to the real footprint's pads by number coincidence would have produced confidently wrong connections, worse than no connections at all. That's resolved: U1's pin numbers are now the real, NXP-Reference-Manual-verified S32K144 64-pin LQFP pinout (see "U1's pinout" above), so it gets normal net assignment like every other part.

Verified after generation, every time: no two footprints' bounding boxes overlap, every net has the same pin count on the PCB as in the schematic (47 nets currently), and a real kicad-cli pcb drc pass comes back with zero connectivity/footprint errors (only a benign "doesn't match library copy" metadata nag on a handful of footprints that's just an artifact of embedding them via script — re-running "Update Footprints from Library" in pcbnew clears it).

A real bug caught and fixed during this verification: the AMPSEAL connector's downloaded footprint uses KiCad's legacy unquoted pad-number syntax, which kiutils parses as a Python int — silently failing every net-lookup for that footprint (all pad numbers are stored as strings everywhere else) until the lookup was fixed to normalize types. Before the fix, J1 looked structurally fine (right pad count, right pattern) but carried zero of its real net assignments.

How the schematic is built

Every part uses a generic placeholder symbol: a rectangle body with pins. For most parts (see below), the pin count/numbers/names are now real, verified against actual manufacturer datasheets — not generic filler.

Connectivity uses three mechanisms, matching normal schematic practice:

  • Drawn wires for the main signal flow: the 12V power chain (fuse → reverse-battery FET → buck), the MCU↔J1 signal bus, and the crystal.
  • Power symbols (+5V, +3V3, GND, VIN) at every power-net connection point. Power nets deliberately never use local labels — mixing local labels with power symbols splits nets in KiCad.
  • Local labels for shared or non-Nano-pinout signals: UART sharing D0/D1, the FB divider, VDDA/AREF/OSC taps, VCAP/BOOT_CAP for the two ICs that need an external charge-pump/bootstrap cap.

Before you route a board from this: swap the placeholder symbols for real library symbols (matching what's now real about the footprints/pinouts) and give it a visual tidy-up. Treat this as a correct netlist and BOM skeleton, not a finished, review-ready schematic.

Sections on the sheet

SectionRefsNotes
Power input & protectionF1, Q1, U3, D1, C1, C10Fuse, reverse-battery ideal-diode + FET, TVS clamp, charge-pump cap
5V buck regulatorU2, L1, C2, R2, R3, C11, C1212V (9–40V transient) → 5V. Now exists only for a Nano-compatibility 5V pin on J1 — the MCU itself no longer runs on this rail
3.3V LDOU4, C3Steps 5V → 3.3V, which is now the primary MCU supply, not just a spare pin
MCU coreU1, Y1, C4–C5, L2, R1NXP S32K144 automotive (real AEC-Q100 qualification), 8MHz placeholder crystal, reset pull-up, VDDA ferrite-filtered
ConnectorsJ1, J2, J3J1 = full Nano-pinout I/O on a TE AMPSEAL 776180-1 (35-pos, right-angle, sealed), J2 = SWD (SWDIO/SWCLK/RESET), J3 = UART (shares D0/D1)

Full component rationale lives in the design-spec document delivered alongside this file — this schematic is the follow-through on that spec.

The MCU: from ATmega328P → STM32 → NXP S32K144 (and losing "Arduino IDE")

This went through two real revisions, both driven by things that turned out not to be true on closer inspection:

  1. ATmega328P → STM32L452xx, because no automotive-qualified 5V-native Arduino-ish chip exists. This looked right at the time.
  2. STM32L452xx → NXP S32K144, because it turned out mainstream STM32 (Cortex-M) parts have no AEC-Q100 qualification at all — confirmed via ST's own community forum: "not a single device in the standard STM32 family meets the AEC-Q specs." ST's real automotive 32-bit line (SPC5) is Power Architecture, not ARM, not Arduino-anything.

NXP's S32K1 family is genuinely AEC-Q100 qualified Arm Cortex-M4F. But:

  • This means giving up Arduino IDE support entirely — not just the STM32duino alias-mapping caveat from before. NXP's own S32K144 EVB documentation is explicit: "the NXP S32K144 is NOT natively supported by the Arduino IDE... development requires the dedicated S32 Design Studio IDE and the S32 Software Development Kit." The "Arduino UNO pin layout" compatibility NXP markets is physical only — no digitalWrite(), Serial, or sketch-based workflow exists for this chip. Programming is via NXP's Eclipse-based IDE and an AUTOSAR-style SDK — a genuinely different, more automotive-industrial development workflow.
  • Still 3.3V logic, not 5V — same consequence as before, unrelated to which 3.3V-logic chip is on the board. J1's dedicated +5V pin (unconnected to the MCU) remains the only genuine 5V on the board.

U1's pinout: from placeholder to real, verified, and fully wired

The 48-pin LQFP placeholder used until now was not just unverified — it was wrong. The S32K144 does not come in a 48-pin LQFP package at all. Confirmed three independent ways against NXP's own S32K1xx Series Reference Manual (Rev 8, 06/2018): S32K144's own pin-mapping sheet only has columns for 64-LQFP/100-LQFP/100-BGA; sibling part S32K142's sheet is the same; 48-pin LQFP is a real NXP package, but it belongs to the smaller S32K116/S32K118 sub-family (Cortex-M0+, not the M4F this board was chosen for). The real minimum package for S32K144 is 64-pin LQFP.

Every earlier attempt at this (this session and prior ones) failed to fetch the "pin table" because it isn't in the datasheet or Reference Manual's visible text at all — NXP ships it as a spreadsheet (S32K144_IO_Signal_Description_Input_Multiplexing.xlsx) embedded as a PDF file attachment inside the Reference Manual, not as text or a table on any page. Regular PDF text extraction (pdftotext, WebFetch) can't see it. Pulled out directly with pypdf's attachment API once a mirror that wasn't blocking the download was found (Farnell, not Mouser/NXP/community.nxp.com — all three of those still 403/timeout).

With the real, verified 64-pin table in hand, U1 is now fully wired — no more placeholder, no more unwired pads:

  • 58 real GPIO pins, of which 5 keep their real default (reset-state) function matching how this board already used them: pin 11 (PTB7/EXTAL) and 12 (PTB6/XTAL) → the crystal, pin 62 (PTC4/SWD_CLK) and 64 (PTA4/SWD_DIO) → the SWD header, pin 63 (PTA5/RESET_b) → reset.
  • VREFH (pin 9, the real ADC voltage-reference pin) goes to J1's AREF — not a placeholder GPIO. AREF on a real board should reach the actual reference input, and now it does.
  • D0–D19 (20 pins, up from the placeholder's 14) and A0–A7 (8 pins, specifically chosen from the 27 real GPIO pins with a genuine ADCn_SEx alternate function — "analog in" is a real capability here, not just a name carried over from Arduino). D14–D19 are new: J1's 6 previously-spare pins now carry them, so all 35 of J1's positions are used, zero spare (see "Nano-pinout I/O" below).
  • The other 25 free GPIO pins aren't wired to anything — J1 has no more physical positions left for them — and are marked no_connect on the schematic with their real pin numbers, not placeholder ones.
  • U1's PCB footprint is now the real bundled KiCad Package_QFP:LQFP-64_10x10mm_P0.5mm, replacing the placeholder LQFP-48_7x7mm_P0.5mm. build_pcb.py's old "leave U1 unwired, its pin numbers might be wrong" special case is gone — U1 gets normal net assignment like every other part now, because its pin numbers are real.

SWDIO/SWCLK were always real, universal Arm Cortex-M debug signals regardless of vendor — that part of the old placeholder note held up. There is no BOOT0-style pin on this family (that was STM32-specific).

Four parts that got real, verified pinouts this session

While researching the MCU footprint, real datasheet research (TI and Nexperia PDFs, pulled and parsed directly) turned up genuine errors in four other parts — now fixed with real pin numbers, not generic placeholders:

  • U2 (buck regulator): LMR33630-Q1's real package is VQFN-HR-12 ("RNX0012C", 2×3mm body, ≤1mm height) — it was never offered in HTSSOP-16 at all, which is what the schematic originally specified. Real 12-pin table verified against TI's datasheet Table 5-1: symmetric VIN/PGND pairs for EMI cancellation, NC(3) tied to SW per the datasheet's own instruction, BOOT(4) needs a cap to SW (added: C11), VCC(5) is an internal 5V rail needing its own decoupling cap (added: C12), PG(8) unused here. This package has no exposed pad at all — an earlier version of this file (and the schematic) had a 13th "EP" pin tied to GND, which was wrong and has been removed; TI's own Pin Functions table has no EP row for this variant. The footprint is custom-built (not a bundled KiCad part, and not the wrong-sized 4×4mm placeholder used earlier) — see build_u2_footprint.py for how the land pattern was derived directly from TI's package drawing (4225021/C, 05/2022) and footprints/TI_RNX0012C_VQFN-HR.pretty/ for the result. This package's pin layout is genuinely irregular — 4 pins down each side, 3 along the bottom, and one larger single pin (SW) on its own at the top — not a simple 3-per-side QFN, so it's worth opening the footprint in KiCad's footprint editor at least once before fab to see the real shape.
  • U3 (ideal-diode controller): the schematic originally specified LM74670-Q1, which turned out to be the wrong part — that's TI's controller for alternator/rectifier diode emulation, not reverse-battery protection. The correct, purpose-built part is LM74700-Q1 ("Low IQ Reverse Battery Protection Ideal Diode Controller"), real 6-pin SOT-23 (DBV) package, real pinout verified against TI's datasheet. It also needs an external charge-pump capacitor across VCAP and ANODE that the schematic never had — added as C10, now confirmed at 100nF against TI's actual design guidance (section 10.1.1.2.3): "VCAP: Minimum 0.1uF is required; recommended value of VCAP(uF) >= 10 x CISS(MOSFET)(uF)". Q1's real Ciss (450pF for the current part, PMV37ENEA, per Nexperia's datasheet) makes the formula's own figure (4.5nF) far smaller than the flat 0.1uF minimum, so the minimum governs - matching TI's own 12V-battery-protection example circuit exactly. The original 10nF value was 10x under TI's stated minimum, not just an unconfirmed guess.
  • U4 (LDO): real candidate TLV733P-Q1 (AEC-Q100) is 5-pin SOT-23 (DBV), not the 3-pin package originally assumed. Real pinout verified against TI's datasheet.
  • Q1 (MOSFET), resolved with a real part swap: the original candidate, Nexperia PMV230ENEA (AEC-Q101, SOT-23, pinout Gate=1/Source=2/Drain=3, verified against Nexperia's datasheet), derated to 0.9A at 100°C ambient - genuinely below F1's fuse rating at the time (originally 1A - see "F1" below for why it's now 2A), meaning the MOSFET could overheat at F1's normal, non-fault operating current, not just a thin margin. Replaced with PMV37ENEA: same SOT-23/TO-236AB package, same pinout, same 60V VDS (no TVS/clamping rework needed) - but RDSon of 37-49mOhm (vs 176-222mOhm) gives 3.5A@25°C / 2.5A@100°C, comfortably above F1's rating with real margin either way (1A originally, 2A now), AEC-Q101 qualified, -55 to 175°C range. One minor, honestly-noted mismatch: PMV37ENEA's max Vth (2.7V) is slightly above LM74700-Q1's own stated preference ("2V to 2.5V maximum") for its light-load regulation scheme - not a hard limit, worth a bench check at light load before final part lock.

A real geometry bug was also caught and fixed while wiring these up: a GND power connection's extra riser wire landed exactly on a neighboring pin's own stub, silently shorting that pin's real net onto GND. Caught via kicad-cli netlist diff (an entire net had vanished), fixed, and now checked automatically on every regeneration (build_schematic.py asserts no two different net labels ever land on the same coordinate).

AEC-Q100 / Q101 / Q200 grade key

Every part's Value field on the sheet is tagged with its actual automotive qualification:

  • Q100 G1 = AEC-Q100 Grade 1 (−40°C to 125°C) for integrated circuits: U2 (buck), U3 (ideal-diode controller), U4 (LDO) — all TI, all verified. U1 (MCU) carries AEC-Q100 (no grade suffix, since the exact grade for this NXP family wasn't independently confirmed this session).
  • Q101 = AEC-Q101, for discrete semiconductors: Q1 (MOSFET), D1 (TVS).
  • Q200 = AEC-Q200, for passives: Y1, C1–C13, R1–R3, L1, L2.
  • F1 (fuse) and J1–J3 (connectors) intentionally have no AEC-Q tag — those categories aren't covered by the AEC-Qxxx family at all; they're qualified against their own standards (SAE J2077 / ISO 8820-3 for F1's real Littelfuse 297 MINI automotive blade fuse, connector-specific automotive standards for J1-J3). Don't read the missing tag as an oversight.

Footprints (for "Update PCB from Schematic")

Every footprint field is a real KiCad library reference, checked directly against the actual .kicad_mod files (not just typed from memory):

  • F1: Keystone 3568 Mini blade fuse holder (Fuse:Fuseholder_Blade_Mini_Keystone_3568, bundled directly in KiCad, 3D model included) - a traditional, physically replaceable automotive blade fuse, not a soldered-down SMD fuse. See "F1: traditional blade fuse" below for why.
  • U2: real, custom-built VQFN-HR-12 footprint (TI_RNX0012C_VQFN-HR:TI_RNX0012C_VQFN-HR-12_2x3mm_P0.5mm) — see above and build_u2_footprint.py.
  • U3: real SOT-23-6 (bundled).
  • U4: real SOT-23-5 (bundled).
  • Q1: real SOT-23 (bundled).
  • J2: Tag-Connect_TC2030-IDC-NL... — note the hyphen KiCad's real file uses (Tag-Connect, not TagConnect).
  • J1 is fully resolved, including a real dimensional check: TE Connectivity AMPSEAL 776180-1 — 35-position, 3-row, 4mm pitch, right-angle through-hole, sealable, −40°C to 125°C / IP67. Its footprint was downloaded from SnapEDA and copied into footprints/TE_AMPSEAL_776180-1.pretty/ for project portability. Checked directly against TE's own real customer drawing (ENG_CD_776180_J.pdf, fetched from te.com's document-delivery system, sheet 2's "RECOMMENDED P.C. BOARD LAYOUT" - a real, dimensioned engineering drawing, not the datasheet's summary page): pin drill (Ø1.75mm), pin pitch (4mm), row stagger (2mm), mounting-hole diameter (Ø2.85mm), and mounting-hole-to-mounting-hole span (57mm) all matched the downloaded footprint exactly. One real, genuinely wrong dimension was found and fixed: the two non-plated mounting holes were 0.5mm off in Y (at 4.5mm instead of 4.0mm) - TE's drawing shows them sitting exactly in-line with the middle pin row, not offset from it. Confirmed via the PDF's own vector geometry (mounting hole's crosshair falls exactly on the middle row's construction line), not just eyeballing the rendered page. Fixed directly in TE_1-776180-1.kicad_mod (a downloaded static library asset, not something this project's scripts generate from scratch, so a direct edit - not a generator script - is the right fix here).
  • U1 is fully resolved too — see "U1's pinout" above. The footprint was the issue here (LQFP48 isn't a real S32K144 package at all), not just the pin-to-net mapping; both are fixed now, using the real Reference-Manual-verified 64-pin LQFP pinout and footprint.

3D models

Four parts had no 3D model showing in KiCad's 3D viewer, for three different reasons:

  • J1 simply never had one — its footprint was a bare SnapEDA download (2D only). Fixed with a real manufacturer STEP file (1-776180-1.step), downloaded and supplied directly by the user, wired into TE_1-776180-1.kicad_mod with a ${KIPRJMOD}-relative (model ...) block (same portability pattern as the footprint itself).
  • F1 (originally the Littelfuse NANO2 SMD fuse) had this same missing- model problem — its (model ...) reference pointed at ${KICAD10_3DMODEL_DIR}/Fuse.3dshapes/Fuse_Littelfuse-NANO2-451_453.step, which doesn't actually exist in this KiCad 10 install (checked directly: the real Fuse.3dshapes folder has 28 files, none of them this one) - a real packaging gap in the bundled library, not a project bug. Moot now: F1 was later replaced entirely with a traditional Mini blade fuse holder (see "F1: traditional blade fuse" below) whose bundled model genuinely exists in this install, so no placeholder/workaround is needed for F1 anymore at all.
  • U2's custom-built footprint (see above) never had a model at all, since it was hand-built from a datasheet rather than downloaded from a library that would normally ship one alongside it.
  • J2 (Tag-Connect TC2030-IDC-NL) is not a bug and got no model: its real footprint (checked directly against the bundled .kicad_mod) is 6 bare connect-type pads plus 2 non-plated locating holes and nothing else — attr exclude_from_pos_files exclude_from_bom even marks it as not a placeable, orderable part. The actual Tag-Connect hardware is a detachable pogo-pin cable head that's never mounted on the assembled board, so there's genuinely no physical body to model here.

U2's placeholder (build_3d_models.py, using cadquery to write a real STEP file, not just a KiCad-only format) is a real-dimension bounding box, not manufacturer-exact art — good enough for a 3D-viewer sanity check and clearance reasoning, not a photorealistic BOM render:

  • U2: 2.0 x 3.0 x 1.0mm, the same real TI package-drawing dimensions already used to build the 2D footprint (build_u2_footprint.py).

Rotated-footprint pad shapes (real KiCad/kicad-cli characteristic, not a script bug)

Building U2's real, densely-pitched (0.5mm) VQFN-HR footprint surfaced a subtle, reproducible characteristic of how KiCad 10.0.4 handles a footprint placed at a 90° rotation: the footprint's overall placement rotation (its (at x y 90)) correctly rotates every pad's position, but does not carry through to each pad's own shape for rendering or DRC purposes unless that pad also has its own local rotation angle set to match. Confirmed with a from-scratch, hand-written two-pad test footprint (no kiutils involved at all) placed once at 0° and once at 90°: only the 90° copy showed a false 0mm-clearance "short," and adding an explicit (at x y 90) to each of its pads (matching the parent's rotation) cleared it completely.

This had been silently affecting every rotated part on this board (R2, R3, J3, Y1) since zone pours were added — invisible until now purely because those parts' pads happen to be close enough to square that an unrotated-vs-rotated shape swap doesn't change anything measurable. U2's 0.6×0.25mm pads were the first asymmetric enough to turn it into a real clearance/solder_mask_bridge DRC failure. Fixed in build_pcb.py: every rotated footprint now gets its pads' local angle set to match its own placement angle, not just the footprint-level rotation. Confirmed fixed two independent ways: the DRC violations themselves cleared, and kicad-cli's own unrelated lib_footprint_mismatch check (which normalizes for rotation before diffing against the library copy) stopped flagging R2/R3/Y1/U2 as "edited" once their pad angles matched their footprint's rotation.

Board position on the page, and readable silkscreen/fab text

Two things fixed together, since both came from the same "everything sat at board-local (0,0)" root cause:

  • The board was jammed in the page's top-left corner. Board.create_new() defaults to an A4 landscape page (297x210mm), and the board's own Edge.Cuts outline started at (0, 0) - which is also the page's own top-left corner. Fixed with a single centering offset (BOARD_OFFSET_X/Y in build_pcb.py), computed once and applied to every already-computed placement (parts, Edge.Cuts, the back-silkscreen logo) - not a rework of the packer itself, which still places everything relative to a (0, 0) corner, just a corner that now sits in the middle of the page instead of flush against it.
  • Every part's Value text was overlapping, illegible. KiCad's own default position for a bare Value property is one fixed offset applied identically to every part - fine on a loosely-spaced board, but this one's densely skyline-packed strip has many parts only 2-4mm apart, and strings like SMCJ33A automotive (AEC-Q101) are far wider than that at any legible font size. Unlike the Reference fix (clearing a part's own bbox is enough, since References are short), Value text needed checking against neighboring parts too. Fixed with a real greedy interval-scheduling lane assignment (sort parts left-to-right, place each Value label in the lowest lane whose last label doesn't overlap it, each successive lane a bit further from the board) plus a smaller font (0.5mm vs Reference's 0.8mm) - see the block above # 5b. Value-label lane assignment in build_pcb.py. A third, unexpected source of the same problem turned up once Value stopped drowning it out: many bundled footprints (mostly the small passives) carry a KiLib_Generator metadata property (e.g. SMD_2terminal_chip_molded) that - unlike Description/Datasheet - does not default to hidden, and was rendering visibly at (0,0,0) on every part. It's pure footprint-wizard metadata, not documentation this board needs, so it's dropped outright rather than also lane-positioned.

F1: traditional blade fuse, not SMD (2026-07-19)

User request: swap F1 to a traditional automotive fuse "to make it easier for the user" (i.e. field-replaceable at any auto parts store, not a soldered-down SMD part). Two real, separate parts now:

  • Holder (soldered to the board): Keystone Electronics 3568, a Mini-blade THT fuse holder, bundled directly in KiCad's own Fuse.pretty library (Fuse:Fuseholder_Blade_Mini_Keystone_3568) with its 3D model genuinely present in this install - no missing-model workaround needed here, unlike the old NANO2 footprint (see "3D models" above). Each of its 2 logical terminals has TWO physical THT pads (redundant solder joints for mechanical strength) - build_pcb.py's net-vs-schematic pin-count check had to be taught to dedupe by (ref, pad.number) rather than count every physical pad, since a real footprint can legitimately have more physical pads than logical pins.
  • Fuse (the swappable/replaceable part, not itself a PCB footprint): Littelfuse 297 series MINI, real SAE J2077 / ISO 8820-3 automotive qualification.

Rating bumped from 1A to 2A: traditional blade-style automotive fuses don't come in a 1A rating at all - 2A is the lowest standard rating in this real fuse family (confirmed by checking Littelfuse's own MINI-series color-code chart, which starts at 2A/gray). Confirmed this doesn't strain anything else in the design: Q1 (PMV37ENEA) already had 2.5A@100°C headroom from its earlier swap (see "Q1" above), comfortably clearing a 2A fuse the same way it cleared the original 1A one.

Board grew from 83.4x35.2mm to 83.4x36.5mm - the Mini blade holder's real footprint (16.5 x 7.24mm) is substantially bigger than the SMD NANO2 footprint it replaced, but the skyline packer absorbed almost all of the size difference by repacking, not by growing the board 1:1 with the part.

One rendering quirk worth knowing, not a real defect: from directly overhead in KiCad's 3D viewer, F1 can appear to visually disappear behind/ under J1's connector body, and from a steep low-angle view can even look like it's nested inside J1's shroud. Checked directly (removed J1 from a scratch copy of the board and re-rendered; separately, compared both parts' real absolute footprint bounding boxes in Python) - the two don't actually overlap (a clean 10.4mm gap in Y between them). It's J1's 3D model's mounting-boss geometry visually covering that screen region from certain angles, a camera/rendering artifact, not a placement bug - DRC confirms zero clearance violations either way.

Case mounting: rounded corners + 2 screw holes (2026-07-19)

User request: round the board's corners and add 2 case-mounting screw holes in the corners opposite J1.

  • Rounded corners: CORNER_RADIUS = 3.0 in build_pcb.py. Edge.Cuts is now 4 straight GrLines (shortened by the radius at each end) + 4 GrArc quarter-circles, one per corner - not just a cosmetic touch, a smaller stress-concentration point at a corner matters for a board this small and this thin. Applies to all 4 corners uniformly, including the two nearest J1 - checked that this doesn't interfere with J1's own real mounting holes or its "PCB EDGE" line (see the J1 edge-cutout section above); real clearance confirmed via DRC, not just eyeballed.
  • 2 mounting holes (MH1/MH2): MountingHole:MountingHole_3.2mm_M3, a real bundled KiCad footprint (3.2mm NPTH clearance hole for an M3 screw, no annular ring, exclude_from_pos_files/exclude_from_bom already set correctly by KiCad itself since it's mechanical, not an orderable part) - matches the M3 hardware size already used by J1's own AMPSEAL mounting bosses, for one consistent screw size across the whole assembly. Placed in the top-left/top-right corners - "the other side of the J1 plug" - 7mm in from each edge.
  • Real keepout, not a hopeful placement: the skyline packer that places every small part now gets seeded with an elevated starting height profile at both ends (initial_skyline in skyline_pack/ best_skyline_pack) sized to the mounting holes' own clearance need, so parts are placed with real knowledge these corners are reserved - the same lesson as J1's "PCB EDGE" fix earlier: a keepout has to be a real input the placer respects, not a hope nothing lands there followed by a DRC scramble. Board grew slightly to accommodate the reserved corners: 83.4x36.5mm -> 83.4x38.7mm.
  • One real bug hit and fixed: MH1/MH2's bundled footprint already has a sensibly-positioned Reference label in the library file, but fp.properties["Reference"] = ref (kiutils' bare-string-only property dict) silently drops that position, so it fell back to KiCad's own (0,0,0) default - landing right on top of the hole itself (confirmed via a real silk_over_copper DRC hit). Same fix as every other part on this board: feed the real intended offset into ref_label_pos so the existing Reference-repositioning patch picks it up too.

Known gaps / things to verify before fab

  • Placeholder symbols are not visually polished — expect to reposition property text and swap in real library symbols for a presentation-quality sheet.
  • BOM part numbers and distributor links were researched and verified live (Digi-Key/Mouser) for every line - real AEC-Q100/Q101/Q200-qualified parts throughout, with two known exceptions: (1) R3 (2.49k, 0603, Yageo AC0603FR-072K49L)'s exact part number is very likely real (matches the confirmed-live neighboring E96 values in the same series) but no live distributor page could be loaded for it specifically - verify before ordering; (2) confirm current stock/pricing hasn't changed since this was last checked, since distributor stock/pricing is a moving target.

Parts

30
QtyValueFootprintReferences
3100nF (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC6, C7, C9
218pF (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC4, C5
2MountingHole_3.2mm_M3MountingHole:MountingHole_3.2mm_M3MH1, MH2
1100nF BOOT cap (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC11
1100nF charge-pump cap (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC10
110k (AEC-Q200)Resistor_SMD:R_0603_1608MetricR2
110k pull-up (AEC-Q200)Resistor_SMD:R_0603_1608MetricR1
110uF X7R (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC1
110uH power (AEC-Q200)Inductor_SMD:L_1210_3225MetricL1
11uF (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC8
11uF VCC decouple (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC12
11uF X7R (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC3
12.49k (AEC-Q200)Resistor_SMD:R_0603_1608MetricR3
122uF X7R (AEC-Q200)Capacitor_SMD:C_0603_1608MetricC2
18MHz (AEC-Q200)Crystal:Crystal_SMD_3225-4Pin_3.2x2.5mmY1
1LM74700-Q1 (AEC-Q100 G1)Package_TO_SOT_SMD:SOT-23-6U3
1LMR33630-Q1 (AEC-Q100 G1)TI_RNX0012C_VQFN-HR:TI_RNX0012C_VQFN-HR-12_2x3mm_P0.5mmU2
1Mini blade holder, 2A Littelfuse 297 fuse (SAE J2077/ISO 8820-3)Fuse:Fuseholder_Blade_Mini_Keystone_3568F1
1NXP S32K144 automotive (AEC-Q100)Package_QFP:LQFP-64_10x10mm_P0.5mmU1
1PMV37ENEA automotive (AEC-Q101)Package_TO_SOT_SMD:SOT-23Q1
1SMCJ33A automotive (AEC-Q101)Diode_SMD:D_SMCD1
1SWD Tag-ConnectConnector:Tag-Connect_TC2030-IDC-NL_2x03_P1.27mm_VerticalJ2
1TE AMPSEAL 776180-1 (35-pos, R/A)TE_AMPSEAL_776180-1:TE_1-776180-1J1
1TLV733P-Q1 (AEC-Q100 G1)Package_TO_SOT_SMD:SOT-23-5U4
1UART headerConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ3
1ferrite bead (AEC-Q200)Inductor_SMD:L_1210_3225MetricL2

Similar boards

  • 4 layers55.5 × 65 mmJitx design, the printed circuit board in 3D

    Jitx design

    gusmanb/logicanalyzer

    24 channel, 100Msps logic analyzer hardware and software

    30 parts5.1kGPL-3.0
  • 4 layers23 × 53 mmEasyduino STM32F103, the printed circuit board in 3D

    Easyduino STM32F103

    Hanqaqa/Easyduino

    Easily dive into different PCB KiCad designs of the most popular microcontroller devboards

    30 parts755CERN-OHL-P-2.0
  • 4 layers112.1 × 64 mmBackplane, the printed circuit board in 3D

    Backplane

    dennisss/dacha

    Monorepo for awesome tools/projects/libraries

    30 parts397Apache-2.0
  • 4 layers15.2 × 19 mmOpenlager, the printed circuit board in 3D

    Openlager

    d-ronin/openlager

    STM32F4 based logging dongle for HIGH RATE logging

    30 parts111
  • 4 layers64.2 × 51.3 mmMiSTeX Pmod, the printed circuit board in 3D

    MiSTeX Pmod

    MiSTeX-devel/MiSTeX-hardware

    Hardware for MiSTeX

    30 parts73
  • 4 layers64.5 × 70.1 mmExAceTestbench, the printed circuit board in 3D

    ExAceTestbench

    cdg66/ExAce

    Framework ExpansionFPGA acceleration module

    30 parts37CC-BY-4.0
  • 4 layers100 × 20 mmOcu2pciex8, the printed circuit board in 3D

    Ocu2pciex8

    inaxeon/ocu2pciex8

    This repository contains the design files for a PCIe x4 (x8 physical) to OCuLink adapter I designed to solve some difficult PC build problems some time ago.

    30 parts34
  • 4 layers104.9 × 102.4 mmCombinedPnl pcb r1, the printed circuit board in 3D

    CombinedPnl pcb r1

    Lebo77/Alarm-Clock

    An ESP32 based alarm clock

    30 parts34

Questions

How big is the Manifold PCB?

It measures 83.4 × 38.7 mm and has 4 copper layers, 1.6 mm thick.

What parts does the Manifold use?

30 parts. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Manifold KiCad files?

From the jessiepullaro414/Manifold repository on GitHub, at the commit this page was made from: the board is Manifold.kicad_pcb and its schematic Manifold.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Manifold design in my own project?

Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).