

Jtag pcb
This is
- Size
- 233.1 × 122.9 mm
- Copper layers
- 2
- Thickness
- 1.6 mm
- Parts
- 196
- Nets
- 225
- Pads
- 908
- Tracks, vias
- 1,334, 0
- Pours
- 2
- Routed
- Yes
- KiCad
- KiCad 8.0 (file 20240108)
- Created
- 4 Jan 2026
- Updated
- 6 Jan 2026
Overview
Jtag pcb is an open-source printed circuit board by ddacot, from the ddacot/fpga-cluster-framework repository on GitHub. It is a 2-layer board of 233.1 × 122.9 mm with 196 parts on 225 nets, routed with 1,334 tracks and 0 vias.
It is built around the BAT54S. Its parts include 128 diodes and 64 connectors. It belongs with the interfaces and adapters boards of this library.
Main components
1README
README.mdFPGA Cluster Framework
A scalable, FPGA-based cluster framework for parallel data acquisition and repeatable evaluation of hardware primitives (e.g., TRNGs, PUFs, and other custom bitstream-generating DUTs). The framework combines:
- Host-side automation (programming, orchestration, data collection, metadata logging)
- A synthesizable FPGA “shell” (control plane + high-throughput capture path)
- A pluggable DUT interface (drop in your TRNG/PUF/primitive and stream data into DDR-backed capture)
This repository is organized to include technical documentation, scripts, RTL, tooling, and PCB designs for the cluster setup.
If you are using this repository as part of a research portfolio, this README is written to be self-contained and reproducible for third parties who want to understand or rebuild the system.
Contents
- What this framework does
- Repository structure
- System overview
- Hardware prerequisites
- Software prerequisites
- Quick start
- Build flow
- Running a capture
- Integrating your DUT (TRNG/PUF/custom)
- Data format and metadata
- Reproducibility checklist
- Troubleshooting
- License and citation
- Contact
What this framework does
This framework is designed to make it practical to collect large, statistically meaningful datasets from hardware primitives across many FPGA instances, enabling you to:
- Run identical designs on multiple boards and compare results across devices
- Sweep configuration parameters and capture results consistently
- Log build + runtime metadata to support repeatable experiments
- Separate control and data responsibilities cleanly:
- Control plane: programming, register writes, run control, status
- Data plane: streaming capture into DDR via DMA (or equivalent)
Typical use cases:
- TRNG / entropy-source characterization and NIST compliance (throughput, bias, stability, robustness)
- PUF response collection across many devices
- Side-channel/physical-variation experiments requiring consistent capture workflows
- Automated regression testing of DUT changes
Repository structure
- documentation/ # PDF technical documentation and design notes
- fpga_cluster_fw/ # Folder containing the firwmare
- fpga_cluster_scripts/ # Host automation (programming, orchestration, data pulls, metadata)
- fpga_cluster_hw/ # FPGA design (shell + DUT interface + top-level integration)
- tools/ # Build helpers (TCL, Makefiles, environment setup, utilities)
- hardware/ # PCB / hardware design files for the Power Delivery and Communication interface
System overview
Conceptual architecture
Data path (capture pipeline):
- [DUT / TRNG / PUF] -> (stream) -> [FIFO/Adapter] -> [DMA/Writer] -> [DDR Capture Buffer] -> Host readout
Control path (orchestration):
- Host scripts program the FPGA, load firmware (if used), configure registers, start/stop capture, and retrieve data.
Design principles
- Pluggable DUT: DUT logic is isolated so you can swap primitives without rewriting the whole platform.
- DDR-backed capture: Enables high-throughput collection without requiring real-time USB streaming.
- Cluster automation: Host scripts should handle multi-board runs, retries, and consistent metadata.
Hardware prerequisites
This framework typically targets FPGA boards with:
- A Xilinx FPGA (e.g., Artix-7 class or similar)
- External DRAM (e.g., DDR3/DDR4) accessible from fabric
- A programming interface (typically JTAG over USB)
Update with your tested hardware:
- Board(s): Xilinx Artix 7
- Memory: DDR3
- Programming interface: JTAG
- Clocking: 100MHz (Adjustable)
Cluster setup notes (practical considerations):
- Use a powered USB hub suitable for the number of boards
- Ensure adequate power delivery and cooling
- Label boards (serial numbers / device IDs) to support reproducible tracking
Software prerequisites
Typical host environment requirements:
- Vivado (synthesis/implementation/bitstream)
- Vitis / XSDK (only if building embedded firmware; optional depending on design)
- Xilinx cable drivers (for JTAG)
- XSDB / xsct (common for scripted programming and debug)
- Python 3 (common for orchestration scripts)
- Common tools:
make,bash,tcl
Tested tool versions (fill in):
- Vivado: 2023.4
- Vitis/SDK: [INSERT VERSION]
- OS: Linux/Windows
- Python: 3.11
Python requirements:
scripts/requirements.txt
Quick start
1) Clone
git clone https://github.com/ddacot/fpga-cluster-framework.git
cd fpga-cluster-frameworkParts
196| Qty | Value | Footprint | References |
|---|---|---|---|
| 128 | BAT54S | Package_TO_SOT_SMD:SOT-23 | D1, D10, D11, D100, D101, D102, D103, D104, D105, D106, D107, D108, D109, D110, D111, D112 +112 |
| 32 | 61201021621 | jtag_pcb:61201021621 | J1, J2, J3, J10, J11, J12, J17, J18, J19, J20, J25, J26, J27, J28, J33, J34 +16 |
| 32 | Conn_01x06_Socket | jtag_pcb:JST_XH_B6B-XH-A_1x06_P2.50mm_Vertical | J13, J14, J15, J16, J21, J22, J23, J24, J29, J30, J31, J32, J37, J38, J39, J40 +16 |
| 4 | MountingHole | jtag_pcb:MountingHole_2.2mm_M2_ISO7380_Pad_TopBottom | H1, H2, H3, H4 |
More from ddacot/fpga-cluster-framework
1- 4 layers206.6 × 142 mm

Similar boards
- 2 layers58.2 × 38.1 mm

Usb sniffer
ataradov/usb-sniffer
Low-cost LS/FS/HS USB sniffer with Wireshark interface
87 parts1.3kBSD-3-Clause - 4 layers94.4 × 72.8 mm

RP2040 base
Twisted-Fields/rp2040-motor-controller
A dual channel brushless motor controller based on the RP2040 microcontroller, designed in Kicad.
325 parts419 - 4 layers72.4 × 95.3 mm

DingoPDM
corygrant/dingoPDM
Hardware - dingoPDM is an open source, affordable automotive PDM (Power Distribution Module). Pre-assembled and tested units are available or the design can be used to build a DIY version.
156 parts128MIT - 2 layers100 × 99.8 mm

- 6 layers203 × 151.8 mm

PDNode Baseboard
DvidMakesThings/HW_PDNode-600-Pro
The PDNode-600 is a professional-grade, 600W USB Power Delivery Unit designed specifically for compact 10-inch rack systems, targeting embedded developers, homelab enthusiasts, test benches, and smart infrastructure.
236 parts86AGPL-3.0 - 6 layers71.5 × 63.6 mm

Sensorboard
CameraNexus/sitina1
Open-source 35mm full-frame (36mm x 24mm) CCD mirror-less interchangable lens camera (MILC). The original goal of this project was to create a digital camera back to convert SLR cameras to DSLR cameras, but has since…
426 parts82MIT - 2 layers248.9 × 120.7 mm

16nx
16n-faderbank/16nx
16nx is a controller for musical instruments. Sixteen faders,MIDI over USB and jack, CV out, and I2C out. Based around RP2040.
171 parts76 - 4 layers137 × 79.5 mm

Questions
How big is the Jtag pcb PCB?
It measures 233.1 × 122.9 mm and has 2 copper layers, 1.6 mm thick.
What parts does the Jtag pcb use?
196 parts, built around the BAT54S. 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 Jtag pcb KiCad files?
From the ddacot/fpga-cluster-framework repository on GitHub, at the commit this page was made from: the board is hardware/jtag_pcb/jtag_pcb.kicad_pcb and its schematic hardware/jtag_pcb/connectors0.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Can I use the Jtag pcb design in my own project?
Its repository states no licence, so its author keeps all rights: ask ddacot before reusing the design.