
Jitx design
gusmanb/logicanalyzer
24 channel, 100Msps logic analyzer hardware and software

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…
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.
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.
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".
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:
python build.py # full pipeline
python build.py --skip-route # skip the slow FreeRouting passrun_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.
python run_drc.py
python run_drc.py path/to/other.kicad_pcbkicad-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:
endpoint_off_grid - every symbol placement now snaps to KiCad's
0.05in (1.27mm) schematic grid.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).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.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.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.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.
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.
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.
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:
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.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.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).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:
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.
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):
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.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.
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:
python route_board.py
python run_drc.pypcbnew.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.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).pcbnew.ImportSpecctraSES(), same bundled-Python mechanism,
writes the routed tracks/vias back into Manifold.kicad_pcb and
saves it.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.
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:
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.
| Section | Refs | Notes |
|---|---|---|
| Power input & protection | F1, Q1, U3, D1, C1, C10 | Fuse, reverse-battery ideal-diode + FET, TVS clamp, charge-pump cap |
| 5V buck regulator | U2, L1, C2, R2, R3, C11, C12 | 12V (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 LDO | U4, C3 | Steps 5V → 3.3V, which is now the primary MCU supply, not just a spare pin |
| MCU core | U1, Y1, C4–C5, L2, R1 | NXP S32K144 automotive (real AEC-Q100 qualification), 8MHz placeholder crystal, reset pull-up, VDDA ferrite-filtered |
| Connectors | J1, J2, J3 | J1 = 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.
This went through two real revisions, both driven by things that turned out not to be true on closer inspection:
NXP's S32K1 family is genuinely AEC-Q100 qualified Arm Cortex-M4F. But:
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.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:
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).no_connect on the
schematic with their real pin numbers, not placeholder ones.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).
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:
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.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).
Every part's Value field on the sheet is tagged with its actual automotive
qualification:
Every footprint field is a real KiCad library reference, checked directly
against the actual .kicad_mod files (not just typed from memory):
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.TI_RNX0012C_VQFN-HR:TI_RNX0012C_VQFN-HR-12_2x3mm_P0.5mm)
— see above and build_u2_footprint.py.Tag-Connect_TC2030-IDC-NL... — note the hyphen KiCad's real file uses
(Tag-Connect, not TagConnect).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).Four parts had no 3D model showing in KiCad's 3D viewer, for three different reasons:
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).(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..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:
build_u2_footprint.py).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.
Two things fixed together, since both came from the same "everything sat at board-local (0,0)" root cause:
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.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.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:
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.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.
User request: round the board's corners and add 2 case-mounting screw holes in the corners opposite J1.
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.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.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.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.| Qty | Value | Footprint | References |
|---|---|---|---|
| 3 | 100nF (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C6, C7, C9 |
| 2 | 18pF (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C4, C5 |
| 2 | MountingHole_3.2mm_M3 | MountingHole:MountingHole_3.2mm_M3 | MH1, MH2 |
| 1 | 100nF BOOT cap (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C11 |
| 1 | 100nF charge-pump cap (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C10 |
| 1 | 10k (AEC-Q200) | Resistor_SMD:R_0603_1608Metric | R2 |
| 1 | 10k pull-up (AEC-Q200) | Resistor_SMD:R_0603_1608Metric | R1 |
| 1 | 10uF X7R (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C1 |
| 1 | 10uH power (AEC-Q200) | Inductor_SMD:L_1210_3225Metric | L1 |
| 1 | 1uF (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C8 |
| 1 | 1uF VCC decouple (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C12 |
| 1 | 1uF X7R (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C3 |
| 1 | 2.49k (AEC-Q200) | Resistor_SMD:R_0603_1608Metric | R3 |
| 1 | 22uF X7R (AEC-Q200) | Capacitor_SMD:C_0603_1608Metric | C2 |
| 1 | 8MHz (AEC-Q200) | Crystal:Crystal_SMD_3225-4Pin_3.2x2.5mm | Y1 |
| 1 | LM74700-Q1 (AEC-Q100 G1) | Package_TO_SOT_SMD:SOT-23-6 | U3 |
| 1 | LMR33630-Q1 (AEC-Q100 G1) | TI_RNX0012C_VQFN-HR:TI_RNX0012C_VQFN-HR-12_2x3mm_P0.5mm | U2 |
| 1 | Mini blade holder, 2A Littelfuse 297 fuse (SAE J2077/ISO 8820-3) | Fuse:Fuseholder_Blade_Mini_Keystone_3568 | F1 |
| 1 | NXP S32K144 automotive (AEC-Q100) | Package_QFP:LQFP-64_10x10mm_P0.5mm | U1 |
| 1 | PMV37ENEA automotive (AEC-Q101) | Package_TO_SOT_SMD:SOT-23 | Q1 |
| 1 | SMCJ33A automotive (AEC-Q101) | Diode_SMD:D_SMC | D1 |
| 1 | SWD Tag-Connect | Connector:Tag-Connect_TC2030-IDC-NL_2x03_P1.27mm_Vertical | J2 |
| 1 | TE AMPSEAL 776180-1 (35-pos, R/A) | TE_AMPSEAL_776180-1:TE_1-776180-1 | J1 |
| 1 | TLV733P-Q1 (AEC-Q100 G1) | Package_TO_SOT_SMD:SOT-23-5 | U4 |
| 1 | UART header | Connector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_Vertical | J3 |
| 1 | ferrite bead (AEC-Q200) | Inductor_SMD:L_1210_3225Metric | L2 |

gusmanb/logicanalyzer
24 channel, 100Msps logic analyzer hardware and software

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





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.

It measures 83.4 × 38.7 mm and has 4 copper layers, 1.6 mm thick.
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.
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.
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).