I present this work as a digital-design and verification project: two synthesizable CRC-32 cores, with a serial implementation and a byte-parallel implementation. The details below record the design, derivation, verification, and synthesis results.
My CRC-32 project is categorized as Digital Design, Verilog, and Verification.
My listed CRC-32 project technologies are Verilog, Icarus Verilog, Yosys, Python, and Make.
I run all 210 frames back to back with random 0–3 cycle gaps and no reset in between.
My testbenches check every echoed message bit or byte.
My testbenches check every appended CRC bit or byte, in the correct order.
My testbenches check that the FSM has returned to IDLE.
My CRC model checks that running the CRC over message + appended CRC always gives the same residue (0x2144DF1C for Ethernet).
My original course simulation fed 55 AA six times into the zero-initialised parallel design, and crc_out showed DE, 18 as the first CRC bytes; the Python model computes RAW CRC(55 AA × 6) = 0xDE18D318, matching the screenshot, and the original RTL re-simulated in Icarus gives the same bytes.
My Yosys synthesis estimates report 2 × CARRY4 for the serial design, and 1 bit per clock for serial versus 8 bits per clock for parallel.
For 8× the throughput, my parallel core costs roughly 1.8× the LUTs.
My flip-flop counts include the 32-bit crc output register and the crc_out echo stage.
My synthesis figures are Yosys estimates.
My project’s figures and waveforms are in docs/images/.
My project requires Python 3.9+, Icarus Verilog, and Yosys for synthesis.
# macOS: brew install icarus-verilog yosys
# Debian/Ubuntu: sudo apt install iverilog yosys
pip install -r requirements.txt
make test # everything: model checks + RTL simulation of all variants
make sim # RTL simulation only, one PASS/FAIL line per design/variant
make waves # VCDs in build/ (open with GTKWave) + regenerate the README waveform
make synth # Yosys resource report
python3 python/crc32_model.py "hello" # CRC of any string in every variant
My project is licensed under the CERN Open Hardware Licence v2, Weakly Reciprocal (CERN-OHL-W-2.0), the same licence as the upstream project.
My modified source files say what was changed at the top.
My serial-core mutation using the original CRC-16-style feedback taps produced FAIL, 3549 mismatches.
My serial-core mutation that shifted out 31 CRC bits instead of 32 produced FAIL, 102 mismatches.
My serial-core mutation that failed to clear count between frames produced FAIL, 31631 mismatches.
My parallel-core mutation with the original stuck count that kept the FSM in FINISH produced FAIL, 8135 mismatches.
My parallel-core mutation with one extra term in an XOR equation produced FAIL, 1016 mismatches.
My parallel-core mutation that sent CRC bytes in the wrong order produced FAIL, 831 mismatches.
My parallel-core mutation that did not re-initialise the register between frames produced FAIL, 1039 mismatches.
My synthesis caveat is that Vivado or ISE results will differ somewhat, and timing (Fmax) has not been measured yet.
My serial CRC core uses feedback crc_reg[31] ^ crc_in; shift register and conditionally XOR 32'h04C11DB7. Its RTL next-state equation is wire [31:0] next_crc = {crc_reg[30:0], 1'b0} ^ (feedback ? 32'h04C11DB7 : 32'h0);.
My serial CRC register uses 32 flip-flops; taps at polynomial terms x³² + x²⁶ + x²³ + x²² + x¹⁶ + x¹² + x¹¹ + x¹⁰ + x⁸ + x⁷ + x⁵ + x⁴ + x² + x + 1.
My serial CRC core is small; one bit per clock.
My byte-parallel CRC core uses eight serial LFSR clocks collapsed into one combinational function using linearity over GF(2). Each next-state bit is an XOR of at most 14 inputs.
My CRC parallel-equation generator uses python/crc32_model.py derives the XOR matrix from the serial model using basis vectors; make equations prints Verilog.
My CRC parallel-equation test parses RTL equations and checks derivation; typo in any of 32 lines fails the test suite.
My CRC interface.load behavior is one-cycle pulse in IDLE starts a frame.
My CRC interface.frame completion signal is d_finish high together with last bit or byte.
My CRC interface.CRC output is updated on the clock that takes the last bit or byte.
My CRC interface.crc_valid behavior indicates finished result; cleared by next load.
My CRC interface.crc_out stream is message echoed one clock late, then 32 CRC bits.
My CRC cores.back-to-back frame behavior is new frame starts on clock right after last CRC bit or byte without reset.
My serial CRC core.reflected variant bit order is sender sets bit order; send each byte LSB-first for reflected variants.
My CRC-32/ISO-HDLC variant uses INIT FFFFFFFF; REFIN/REFOUT 1/1; XOROUT FFFFFFFF; check CBF43926; Ethernet, zlib, PNG, gzip.
My CRC-32/BZIP2 variant uses INIT FFFFFFFF; REFIN/REFOUT 0/0; XOROUT FFFFFFFF; check FC891918; bzip2, ATM AAL5.
My CRC-32/MPEG-2 variant uses INIT FFFFFFFF; REFIN/REFOUT 0/0; XOROUT 00000000; check 0376E6E7; MPEG-2 transport streams.
My CRC-32/JAMCRC variant uses INIT FFFFFFFF; REFIN/REFOUT 1/1; XOROUT 00000000; check 340BC6D9; ISO-HDLC without final inversion.
My RAW CRC variant uses INIT 00000000; REFIN/REFOUT 0/0; XOROUT 00000000; check 89A1897F; plain remainder computed by original design.
I built crc_coding, a Verilog repository on my GitHub, with synthesizable serial and byte-parallel CRC-32 generators. The README explains how CRCs work and documents the design choices, example, verification, and synthesis estimates. It is listed on my github profile.
My crc_coding repository is Verilog; Started 2026-09, last updated 2026-09.
My repository describes a Verilog repository with synthesizable serial and byte-parallel CRC-32 generators, using polynomial 0x04C11DB7.
My CRC-32 generators use polynomial 0x04C11DB7.
My crc32_serial takes 1 bit per clock; crc32_parallel takes 8 bits per clock.
My CRC-32 cores use the Rocksoft parameters INIT, REFIN, REFOUT, XOROUT; Ethernet/zlib CRC-32 and other common 32-bit variants.
My CRC-32 detects every single-bit error, every double-bit error, any odd number of bit errors, and every burst error up to 32 bits long.
My CRC explanation is: GF(2) polynomial division remainder is a check value; receiver repeats division and a non-zero or unexpected remainder indicates corruption.
My LFSR mapping uses one flip-flop per remainder bit and an XOR gate wherever the generator polynomial has a 1.
My RTL uses the direct form, producing an equivalent remainder without the extra 32 padding clocks.
The textbook augmented form pads the message with r zeros and feeds it in at the low end. In the direct RTL form, each incoming bit is XORed with the bit leaving the top of the register. The parallel design unrolls eight LFSR steps into one XOR network.
My default configuration gives CRC-32("123456789") = 0xCBF43926.
My example hashes ASCII "123456789" (bytes 31–39); crc holds CBF43926 on the clock that takes the last byte, then the next four clocks append 26 39 F4 CB least-significant byte first.
My self-checking Icarus Verilog testbenches cover 2 designs × 5 CRC variants × 210 frames, comparing every output bit with the Python model.
My mutation testing detects all 7 deliberately injected RTL bugs.
My Python golden model agrees with zlib.crc32 / binascii.crc32 and published check values for all 5 variants.
My Yosys synth_xilinx estimates are parallel ≈ 138 LUTs + 78 FFs, serial ≈ 76 LUTs + 74 FFs.
My example waveform was simulated with Icarus Verilog and drawn with python/wave_svg.py.
The verification method checks the Python golden model against Python’s zlib.crc32 and binascii.crc32, as well as published check values. Synthesis estimates use Yosys synth_xilinx.