Skip to the content
2 layers71.9 × 85.6 mmECE692 3, the printed circuit board in 3D

8-channel USB digital logic analyzer built around the STM32F446RE board with real-time protocol decoding in Go and a Python GUI.

Size
71.9 × 85.6 mm
Copper layers
2
Thickness
1.6 mm
Parts
22
Nets
83
Pads
193
Tracks, vias
243, 7
Pours
2
Routed
Yes
KiCad
KiCad 10.0 (file 20260206)
Created
14 May 2026
Updated
19 Oct 2026

Overview

ECE692 3 is an open-source printed circuit board by raghavbharath, from the raghavbharath/usb-logic-analyzer repository on GitHub, published under the MIT licence. It is a 2-layer board of 71.9 × 85.6 mm with 22 parts on 83 nets, routed with 243 tracks and 7 vias.

Its parts include 6 ICs, 5 resistors, 4 connectors, 1 capacitor and 1 diode. It belongs with the sensors and measurement boards of this library.

README

README.md

ECE692 Final Project - USB Digital Logic Analyzer

Main repository: https://github.com/ragusauce4357/ece692-final-project

Group Members: Raghav Bharathan (raghavbharath), Arnav Revankar (avr34), Gonzalo Villanueva, William Dougherty (Will35084), Bryan Galecio (bryangalecio04)

This project is a custom USB logic analyzer built around two STM32F446RE Nucleo boards, developed as our final project for ECE 692 at NJIT. The system captures digital signals from an external device under test, decodes UART, SPI, I2C, and CAN protocols using a Go signal decoder, and visualizes the results in real time through a Python GUI.

How It Works

The transmitter Nucleo generates test signals over UART, SPI, I2C, and CAN. The receiver Nucleo samples up to 8 digital channels simultaneously at 1MHz using DMA-driven GPIO capture, packages the raw samples into packets, and streams them to a host PC over USB CDC. A Go application reads the packet stream, decodes UART, SPI, and I2C from the raw samples, and forwards the results to a Python GUI over TCP. CAN frames are decoded inside the STM32 hardware itself by the bxCAN peripheral and forwarded directly.

Repository and Branch Structure

Note: This repository is organized across several feature branches, with each of us making contributions in different areas. The master branch contains the integrated codebase including the firmware configured for 10kHz sampling over ST-Link USART, which was used during final testing and demonstration. The 1MHz USB CDC configuration and other work can be found in the individual feature branches (feature/stm32-firmware, feature/SignalDecoder, feature/GUI, feature/PCB, feature/3DEnclosure). The feature/test branch contains the final snapshot used during the live demo.

text
firmware-receiver/     # STM32 receiver firmware (STM32CubeIDE)
firmware-transmitter/  # STM32 transmitter firmware
SignalDecoder/         # Go signal decoder application
gui/src/               # Python GUI
PCB/                   # KiCad schematic and PCB layout
enclosure/             # 3D printable STL files
docs/                  # Datasheets and reference manuals

Firmware

The receiver firmware runs on an STM32F446RE at 168MHz. TIM1 generates a 1MHz update event that triggers DMA2 on each tick. The DMA reads the lower byte of GPIOC (PC0-PC7) into a 1024-byte circular ping-pong buffer. When the first half fills, an interrupt fires and the firmware packages bytes 0-511 into a 516-byte logic packet with a 2-byte header, sequence number, and XOR checksum, then sends it over USB CDC. The second half fires the same way. This design keeps sampling continuous with no gaps.

CAN is handled separately. The bxCAN peripheral runs at 500kbps and decodes incoming frames entirely in hardware, delivering a clean frame (ID, DLC, data bytes) to an RX interrupt handler. The firmware packages this into a variable-length CAN packet and sends it over USB CDC alongside the logic packets.

The transmitter firmware runs the same clock config and outputs test signals in a loop every second: UART at 115200 baud, SPI at ~164kHz, I2C to a dummy address (0x52), and a CAN frame with ID 0x123 and payload 0xCAFEBABEDEADBEEF.

Packet formats:

  • Logic: [0xAA][0xBB][seq][512 bytes][XOR checksum] = 516 bytes
  • CAN: [0xCC][0xDD][seq][ID_H][ID_L][DLC][0-8 data bytes][XOR checksum] = variable length

Go SignalDecoder

The SignalDecoder reads the USB serial stream from the receiver. A ReadByteStream goroutine reads into a 1024-byte buffer and pushes raw byte slices into a buffered channel. A Run coordinator consumes from the channel, scans for 0xAA 0xBB or 0xCC 0xDD headers using a pending accumulation slice to handle packets that span across reads, validates XOR checksums, and detects dropped packets via sequence number wraparound. Logic packets go to the UART, SPI, and I2C decoders. CAN packets are forwarded directly to Python over TCP.

CLI flags: --port, --protocol, --pins, --duration

Python GUI

The GUI launches the Go binary as a subprocess with the appropriate CLI arguments, then connects to its TCP socket to receive decoded data. A background thread parses incoming packets and emits Qt signals to the main thread.

The waveform view shows 8 digital channels plus a synthetic CAN row reconstructed from decoded frame timestamps and DLC. Features include a crosshair cursor, a permanent multi-pair measurement tool with delta-time and frequency readout, a vertical scrollbar, protocol decode annotations color-coded by type, and a CAN decode table. Captures can be saved and loaded as JSON.

Run in simulator mode (no hardware needed, but a few tweaks might need to be made to the code):

text
python gui/src/gui.py --test

PCB

The PCB is a breakout shield that plugs onto both Nucleo boards simultaneously via their morpho headers. It carries a TXS0108E 8-channel bidirectional level shifter for the probe inputs, two SN65HVD230 CAN transceivers (one per Nucleo), per-channel 1kohm series resistors and BAT85 Schottky diodes for overvoltage protection, 4.7kohm I2C pull-ups, a 10-pin probe header, a CANH/CANL screw terminal, and 120ohm CAN termination resistors at each bus end. The schematic is split into receiver and transmitter sub-sheets under a hierarchical root sheet in KiCad.

Enclosure

3D-printable STL files for a custom enclosure are in enclosure/.

Dependencies

Python:

text
pip install -r gui/src/requirements.txt

Go:

text
cd SignalDecoder && go build

Parts

22
QtyValueFootprintReferences
25.1kResistor_SMD:R_0805_2012Metric_Pad1.20x1.40mm_HandSolderR3, R4
2NUCLEO-F446REConnector_PinHeader_2.54mm:PinHeader_2x19_P2.54mm_VerticalU5, U6
2Screw_Terminal_01x02TerminalBlock:TerminalBlock_MaiXu_MX126-5.0-02P_1x02_P5.00mmJ1, J2
110kResistor_SMD:R_0402_1005Metric_Pad0.72x0.64mm_HandSolderR2
1150Resistor_SMD:R_0805_2012Metric_Pad1.20x1.40mm_HandSolderR5
117kResistor_SMD:R_0402_1005Metric_Pad0.72x0.64mm_HandSolderR1
11uFCapacitor_THT:C_Disc_D7.5mm_W5.0mm_P5.00mmC1
1CAN_BUS_TRANSCEIVER1Connector_PinSocket_2.54mm:PinSocket_1x06_P2.54mm_VerticalU1
1CAN_BUS_TRANSCEIVER2Connector_PinSocket_2.54mm:PinSocket_1x06_P2.54mm_VerticalU2
1Conn_01x12Connector_PinHeader_2.54mm:PinHeader_1x12_P2.54mm_VerticalJ2
1LEDLED_THT:LED_D5.0mmD1
1LEVEL_SHIFTERfootprints:LEVEL_SHIFTERU4
1LODPackage_TO_SOT_SMD:SOT-23-5_HandSolderingU3
1LOGOfootprints:Logo_v3_newG***
1TYPE-C_16PIN_2MD__073_symbols1:SHOUHAN_TYPE-C_16PIN_2MD__073_J1

The 18 most common of 22 parts.

Similar boards

  • 2 layers158 × 11 mmDaylight Matchstick, the printed circuit board in 3D

    Daylight Matchstick

    VoronDesign/Voron-Hardware

    Cool Hardware designed by the Voron Design group

    22 parts1.1kGPL-3.0
  • 2 layers57 × 65 mmRgb to hdmi, the printed circuit board in 3D

    Rgb to hdmi

    hoglet67/RGBtoHDMI

    Bare-metal Raspberry Pi project that provides pixel-perfect sampling of Retro Computer RGB/YUV video and conversion to HDMI

    22 parts1kGPL-3.0
  • 2 layers81 × 57.2 mmRP2040-Macropad, the printed circuit board in 3D

    RP2040-Macropad

    hackclub/OnBoard

    💡 Join 1,000 teenagers and make your first PCB with a $100 grant!

    22 parts915
  • 2 layers54.6 × 70.9 mmBeagleLogic Cape, the printed circuit board in 3D

    BeagleLogic Cape

    abhishek-kakkar/BeagleLogic

    A Software Suite that implements a logic analyzer with the PRU on the BeagleBone / BeagleBone Black.

    22 parts479GPL-3.0
  • 2 layers66.4 × 24.5 mmConnecting piece, the printed circuit board in 3D

    Connecting piece

    Chrismettal/flipper-zero-backpacks

    Backpack-style addon boards for the Flipper Zero!

    22 parts456
  • 2 layers51 × 70 mmDMG A04-01, the printed circuit board in 3D

    DMG A04-01

    HDR/NintendoPCBs

    Replacement pcb's for Nintendo games.

    22 parts321
  • 2 layers27.8 × 16 mmSpi 1v8 level shifter, the printed circuit board in 3D

    Spi 1v8 level shifter

    CRImier/MyKiCad

    My KiCad boards. Can't be bothered uploading individually anymore, so here you go.

    22 parts253GPL-3.0

Questions

How big is the ECE692 3 PCB?

It measures 71.9 × 85.6 mm and has 2 copper layers, 1.6 mm thick.

What parts does the ECE692 3 use?

22 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 ECE692 3 KiCad files?

From the raghavbharath/usb-logic-analyzer repository on GitHub, at the commit this page was made from: the board is PCB/ECE692_3.kicad_pcb and its schematic PCB/ECE692.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the ECE692 3 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).