FPGA Systems From Pins To Bitstreams

Complete FPGA systems emerge when pins, protocols, clocks, arithmetic, and configuration become one design.

This work follows each machine through pin-level signal behavior, packet parsing, clocking, arithmetic schedules, configuration transport, device primitives, open toolchains, and the Linux or browser surface that controls it.

Binary32 divider RF receiver 106-channel one-pin TX Ethernet reprogrammer Physical MUX tiles Learn FPGA And Verilog Discuss FPGA work
Physical spectrum of 106 independently moving FPGA RF channels across the complete 222 to 225 megahertz grid
One HX8K creates 106 concurrent FM lanes on a 120-slot grid, reduces their complex sum through continuous bit-serial arithmetic, and switches the complete 3 MHz band through N16.

The System Lives Where The Blocks Meet

An FPGA joins electrical behavior, clocks, packet structure, state, routing, and configuration in one programmable machine. The decisive engineering happens at those joins.

The systems here span Lattice iCE40 and Xilinx 7-series hardware, Verilog and SystemVerilog, vendor primitives, Yosys-based toolchains, raw network framing, RF threshold crossings, and direct reconfiguration of one FPGA by another.

For a first encounter with FPGAs, begin with All Things All The Time: FPGA And Verilog From First Principles. It builds upward from Boolean logic, LUTs, and flip-flops through Verilog, simulation, synthesis, placement, routing, and a programmed iCE40 board.

Seven FPGA Paths From Signal To System

Illustrated one-pin FPGA FM receiver path from thresholded RF to recovered audio

RF receive

One-Pin FPGA FM Receiver

A thresholded RF stream enters one logical differential iCE40 input site. DDR decisions become I/Q bit lanes, DDS sign bits control four XOR-and-popcount terms, and a later I/Q cross product recovers FM phase movement before sigma-delta audio.

Operating video, selected UP5K source, and the build path trace the receiver from a single input site to audible output.

Physical 120-slot spectrum with 106 occupied FPGA transmitter channels and 14 deliberate holes

RF transmit · 106 concurrent channels

106-Channel One-Pin FPGA Transmitter

The HX8K implements 106 independent 24-bit phase engines, deterministic FM motion, twin 128-leaf bit-serial I/Q trees, signed sigma-delta conversion, and a 7.5 MHz complex rotation before four 216 MHz phases converge on N16.

The complete SystemVerilog, support RTL, constraints, build, volatile-SRAM loader, hardware guide, and ready-to-load image are MIT licensed. Own the architecture and build it.

January 2020 working-reprogrammer waveform with green digital traces

Network and configuration

Ethernet To An Adjacent iCE40

A 2020 multi-file system receives RMII Ethernet, answers ARP, ingests a fixed-layout bitstream through IPv4/UDP, stores it in FPGA RAM, and controls an adjacent iCE40LP384 configuration interface directly.

The Linux sender combines UDP, epoll, XCB, EGL, and GLES2 in one control shell.

Arithmetic scheduling

64-Bit Continuous Serial Multiplier

The SystemVerilog core produces one low 64-bit product every 64 clocks at 216 MHz: 3.375 million products per second from 254 LUT4s and 635 flip-flops.

Twelve independent cores fit the HX8K and deliver 40.5 million products per second. The article publishes the RTL, build, utilization, host verifier, and physical run data.

Binary32 arithmetic

Binary32 Serial Divider: 6.75 Million Divisions/s

Raw IEEE binary32 words cross the boundary LSB first while significands, exponents, and signs move through one-bit internal streams. A 216 MHz HX8K accepts a new finite-normal division every 32 clocks.

Three serial multipliers, eight add/subtract engines, and three comparators turn the continuous schedule into 6.75 million correctly rounded finite-normal divisions per second, with open RTL and complete rebuild files.

Tangible logic

Physical MUX Tiles For STEM EE

Input, constant, selector, route, and intersection PCB variants turn circuit role, orientation, and topology into objects that learners can assemble and change by hand.

This physical teaching alphabet carries the logic of MUXes and LUTs out of diagrams and into palm-scale compositions.

Spatial reconfiguration

Cartilage

Cartilage organizes cells into locally coherent regions with owned ports, state, routing, and replacement. Its learning path runs from one MUX through LUTs, drivers, clock distribution, state, timing, metal, composition, and runtime instantiation in adjacent space.

Run Cartilage Core, then follow the editor, simulator, ownership, and recovery roadmap. The architecture invites funding, implementation partners, and contributors.

Devices, Primitives, And Toolchains

Lattice targets
iCE40 UP5K, HX4K/HX8K, and LP384 source, builds, radio paths, and configuration control
Xilinx target
Arty / 7-series Ethernet controller with an adjacent-device reprogrammer
HDL
Verilog and SystemVerilog with PLLs, global buffers, DDR input, RMII, RAM, CRC, and configuration-pin control
One-bit arithmetic
A 254-LUT4 64-bit low-product multiplier at 3.375M/s and a binary32 divider at 6.75M/s on the HX8K at 216 MHz
Open toolchains
Yosys, nextpnr, IceStorm, arachne-pnr, IcePack, Verilator, and Logisim
Host systems
Linux UDP and epoll, XCB events, EGL/GLES2, raw WebGL/GLSL, and browser-visible tests

One Engineer Can Follow The Whole Computation

The useful abstraction ends where it stops matching the machine.

The right intervention may take the form of an arithmetic schedule, an FPGA input threshold at the front of a receiver, an ARP response and bitstream path with no CPU in the datapath, a configuration port between devices, or a circuit alphabet that a learner can hold.

That cross-layer range turns hardware, software, protocols, and physical behavior back into one tractable system—the point where difficult product and research problems often yield.

Bring The FPGA Problem That Does Not Fit The Usual Stack

Start with an RTL path, signal interface, timing problem, packet boundary, reconfiguration mechanism, teaching instrument, or architecture. Together, we can turn it into a machine that a team can run, inspect, and develop.