# Logic Boole 16

![The Logic Boole 16 board at an angle: two keyed pod connectors at the front, the FPGA in the middle, USB-C on the right and a 40-pin header at the back.](https://nearfieldsupply.com/img/lb16/hero.webp)

*Renders of the revision C design. The first five boards are built.*

Kit 16 Instruments Open source

An open-source 16-channel logic analyzer on USB 3. It runs from one USB-C cable on a computer, or sits on a Raspberry Pi 4 or 5 as a HAT+.

**Open-source hardware.** The schematic, the board layout, the FPGA design, the firmware and the software are all published under open licenses: read them, change them, build your own.

- **200 MS/s** on all 16 channels: a sample every 5 ns, measured on the first boards

$99 ~~$149~~ Not on sale yet

**First-batch price, one time only.** The first four boards are $99. After that the board is $149.

Not on sale yet [Datasheet](https://nearfieldsupply.com/downloads/logic-boole-16/logic-boole-16_datasheet.pdf)

Ships in the United States only. Shipping and any sales tax are added at checkout. Payment is taken by Stripe: this site never sees your card. [Shipping and returns](https://nearfieldsupply.com/shipping/)

#### In the box

- The board, assembled, with its headers soldered on
- USB-C cable: not included. Use one made for USB 3
- Spacers and screws for a Raspberry Pi: not included. It takes 4 × M2.5 × 16 mm spacers and 8 × M2.5 × 6 mm screws
- Probe leads: not included

## What it does

*Measured with 3.3 V signals unless marked*

- **16** channels in two pods of 8, each pod with its own threshold
- **85 MHz** clocks captured whole, on each of the 16 inputs of one board
- **0.3–3 V** threshold for each pod in 0.75 mV steps, so one capture can hold two logic voltages
- **75–80 ns** from the trigger sample to the trigger output, to start a scope
- **1 MΩ / 10 pF** at the probe pin, on every channel
- **±25 V** on any input, powered or not

### A trigger in the FPGA

The trigger runs on every sample at the full rate: edges, levels, pulses by their length and levels that have lasted, with up to four stages in turn. A trigger input lets another instrument start the capture.

Each channel has a glitch filter up to 1.25 µs in 5 ns steps, and a capture can sample on your circuit's own clock up to 50 MHz.

### It streams as it samples

Samples go to the host over USB 3 as they are taken, so a capture's length is set by the host's memory. The longest capture so far is 600 million samples.

All 16 channels stream at 100 MS/s for any signal, and at 200 MS/s for signals that change in up to 96 million samples a second.

## Find your way around

*Everything you plug into is on an edge*

*Drawing: Front of the Logic Boole 16 board, labelled: 40-pin stacking header; Pi bus jumpers; Power from USB or the Pi; A threshold for each pod; 16 fast comparators; Status LEDs; Pod A: channels A0–A7; 4 × M2.5 mounting holes; Infineon FX3; Spartan-6 FPGA; USB-C; Inputs rated ±25 V; Trigger in and out; Pod B: channels B0–B7.*

*The front of the board.*

## The software

*macOS and Linux. Not Windows*

![The app in a browser: sixteen channels of waveforms, and the analyzers it found with the messages they decoded.](https://nearfieldsupply.com/img/lb16/app.webp)

*The app, here showing its built-in demo signals, which need no board.*

### The app

Opens in your browser: waveforms, a threshold for each pod, the trigger, and decoders for I²C, SPI and serial that it can find by itself.

### Command line and Python

Capture to a file for PulseView, a waveform viewer or a spreadsheet. Run any of sigrok's decoders on a capture. Commands print JSON for scripts.

### AI agents

An agent can use the board by itself, through the command line with a skill file or through a Model Context Protocol server.

```
# Check the computer and the board
./logicboole check

# Wait for B0 to fall, and keep the millisecond after it
./logicboole capture reset.sr --rate 200M --time 1ms --trigger "B0=f"

# What a protocol decoder finds in a saved capture
./logicboole decode bus.lb16 i2c scl=A1 sda=A0
```

## On a Raspberry Pi

*A HAT+ for the Pi 4 and Pi 5*

![The board mounted on a Raspberry Pi 5 on four spacers, with a short USB cable from the board to one of the Pi's USB ports.](https://nearfieldsupply.com/img/lb16/pi_front.webp)

*On a Raspberry Pi 5, with the link cable to the Pi's USB 3 port. A render. The spacers, the screws and the cable are yours to supply.*

- **Stack another HAT on top.** As shipped the board connects to none of GPIO 2 to 27, and all 40 pins pass through.
- **Powered by either side.** It runs from the Pi's 5 V pins, from USB-C, or both, and never feeds power back into the Pi.
- **Capture the Pi's own buses.** Close solder jumpers, and a capture can take the Pi's I²C, UART and SPI lines in place of pod channels.
- **Room for the Active Cooler.** The board sits 16 mm above the Pi, and nothing but the header is fitted underneath.

## Specifications

*Board revision C · datasheet revision C*

### Capture

| Item | Value |
| --- | --- |
| Channels | 16 digital, in two pods of 8 |
| Sample rate | 200 MS/s, or 200 MS/s divided by a whole number |
| Streaming, USB 3 | Raw: 16 channels at 100 MS/s, any signal. Run-length: 16 channels at 200 MS/s, for signals that change in up to 96 million samples a second |
| Fastest signal | Clocks up to 85 MHz, pulses down to 6 ns |
| Before the trigger | The newest 8184 words: 16,368 samples in the raw format |
| Trigger header | TRIG IN, and TRIG OUT 75 to 80 ns after the trigger sample |
| Glitch filter | For each channel, from off to 1.25 µs in 5 ns steps |
| Capture clock | The circuit's own clock, up to 50 MHz |

### Inputs, link and board

| Item | Value |
| --- | --- |
| Logic levels | 1.2 to 5 V |
| Thresholds | 0.3 to 3.0 V in 0.75 mV steps, one for each pod |
| Channel skew | 1.4 ns between the earliest and the latest of the 16 inputs of one board |
| Maximum input | ±25 V |
| Host link | USB-C. USB 3 at 5 Gbit/s; USB 2.0 works and carries a ninth as much |
| Power | 5 V from USB-C or the Pi's header, about 1 W |
| Main parts | Spartan-6 XC6SLX9 FPGA, Infineon EZ-USB FX3, 16 fast comparators |
| Size | 82 × 86 mm, four layers, parts on the top side only |

- [PDF Datasheet, revision C 18 pages · 3.1 MB](https://nearfieldsupply.com/downloads/logic-boole-16/logic-boole-16_datasheet.pdf)
- [PDF Quick start guide 2 pages · 1.0 MB](https://nearfieldsupply.com/downloads/logic-boole-16/logic-boole-16_quick-start.pdf)
- [GIT Design files, firmware and software GitHub ↗](https://github.com/mgwalkerjr95/logic-boole-16)

## Open hardware

*Read it, change it, build your own*

- Open hardware: CERN-OHL-S v2
- Software: GPL-3.0-or-later
- Firmware: MIT

One repository holds the whole of board revision C: the KiCad project and the files the boards were made from, the FPGA design in Verilog with its test benches, the firmware's source, and the host software.

The board keeps no firmware. The host loads it each time it connects, so nothing you load can brick it.

[View on GitHub](https://github.com/mgwalkerjr95/logic-boole-16)

**What is not open.** The built firmware image also holds code of Infineon's FX3 SDK libraries, which stays under Infineon's license: the software downloads the image once. The name Logic Boole and its logo are not part of the licenses.

## Good to know

*Before you pack it*

- **It needs a host.** A computer or a Raspberry Pi loads the board every time it connects and holds the capture.
- **Digital only.** Sixteen logic inputs. No analog channels and no pattern generator.
- **200 MS/s needs idle time to stream.** A signal that changes in 100 million samples a second or more overflows after 4.5 ms. Use the raw format at 100 MS/s for such signals.
- **Thresholds stop at 3 V.** That covers 5 V logic at the usual half-way point, 2.5 V.
- **The inputs are not isolated.** Their ground is the USB cable's ground and the Raspberry Pi's ground.
- **The first load needs the internet.** The software downloads the firmware image once, about 110 kB.

## From the field guide

*Near Field Notes: the notes behind this board*

[Note 37 · Power · What do a chip fuse, a polyfuse and an eFuse do when a USB port shorts? · Read before you power a board from a laptop.](https://nearfieldnotes.com/notes/fuses/)

[Note 13 · Power · Which kind of capacitor should feed a load? · Six parts that store charge, each running the same load.](https://nearfieldnotes.com/notes/capacitor-types/)

[Note 47 · History · Who invented USB-C? · The connector every kit here plugs into.](https://nearfieldnotes.com/notes/who-invented-usb-c/)

---

Source: https://nearfieldsupply.com/boards/logic-boole-16/
