Verilog数字系统基础设计中的循环冗余校验

CRC（循环冗余校验）

CRC介绍

临时“插播”，后面有实例。

CRC（Cyclic Redundancy Check，循环冗余校验）是数据帧传输中常用的一种差错控制编码方式，针对要发送的数据帧，使用一些特定的多项式可以计算出CRC校验结果，CRC校验结果和原始数据一起传输到接收端。

接收端在接收数据的同时按照相同的多项式对接收数据进行校验运算，并将校验结果和接收的结果进行对比，如果二二者相同则认为没有发生传输错误；如果不同，则认为是发生了传输错误。

从理论上说，如果接收端计算出的CRC值与接收到的CRC值匹配，数据中仍有出错的可能，但由于这种可能性极低，在实际应用中可以视为0，即没有错误出现。

当接收端CRC不匹配时，接收端可以采取不同的措施，例如，丢弃数据包并通知对端，要求对端重新发送，或者只进行丢弃处理，通过高层协议实现数据的重传。

串行CRC计算

计算CRC步骤如下：

选择一个CRC算法或生成多项式，如CRC8-CCITT的生成多项式表示为（x^8+x^2+x+1）;

CRC8硬件上由8个触发器实现，整合为一个移位寄存器，称为CRC寄存器。

计算CRC之前，CRC寄存器初始化为一个已知的值，称为CRC初始值；这里要求确定的初始值，因为接收端的CRC校验电路需要使用和发送端相同的初始值；

CRC寄存器初始化之后，每个时钟都有一个数据比特输入，与当前寄存器的值共同参与计算；CRC校验电路中，一些寄存器的输入直接来自前级的输出，有的是前级的输出与当前输入数据进行逻辑运算的结果；

在每个周期，新的数据不断输入，CRC寄存器不断更新，直到最后一个输入比特到达；

当最后一个数据比特到达时，CRC内部所存储的就是最后的CRC校验结果；

正如上面提到的，CRC校验结果的位宽取决于具体的CRC算法。例如，CRC5-USB中的CRC校验结果为5比特，CRC8-CCITT中CCRC校验结果为8比特；

在最后1个数据比特发出后，存储在寄存器中的的CRC校验结果逐比特依次输出，直至最后一个比特。可以看岀，校验结果紧跟在用户数据后面输出；

以下是CRC8-CCITT算法图：

module CRC8_CCITT

（clk，reset，

din，

init_crc，

calc_crc，

crc_out）;

input clk，reset;

input din;

input ［7:0］init_crc;

input calc_crc;

output ［7:0］ crc_out;

parameter CRC_INIT_VALUE = 8‘hFF;

reg ［7:0］crcreg，crcreg_nxt;

wire ［7:0］ newcrc;

wire ［7:0］ crc_out;

assign newcrc［0］ = crcreg［7］^din;

assign newcrc［1］ = （crcreg［7］^din）^crcreg［0］;

assign newcrc［2］ = （crcreg［7］^din）^crcreg［1］;

assign newcrc［3］ = crcreg［2］;

assign newcrc［4］ = crcreg［3］;

assign newcrc［5］ = crcreg［4］;

assign newcrc［6］ = crcreg［5］;

assign newcrc［7］ = crcreg［6］;

always @（*）begin

if（init_crc）

crcreg_nxt = CRC_INIT_VALUE;

else if（calc_crc）

crcreg_nxt = newcrc;

else

crcreg_nxt = crcreg;

end

always @（posedge clk or negedge reset）begin

if（！reset）

crcreg = CRC_INIT_VALUE;

else

crcreg = crcreg_nxt;

end

assign crc_out = crcreg;

endmodule

测试testbench

`timescale 1ns/1ns

module testbench_CRC8_CCITT;

reg clk_tb，reset_tb;

reg din_tb;

reg init_crc_tb，calc_crc_tb;

wire ［7:0］ crc_out_tb;

parameter CLK_HALF_PERIOD = 5;

parameter RST_DEASSERT_DLY = 100;

initial begin

clk_tb = 1’b0;

forever begin

#CLK_HALF_PERIOD clk_tb = ~clk_tb;

end

end

initial begin

reset_tb = 1‘b0;

#RST_DEASSERT_DLY reset_tb = 1’b1;

end

initial begin

din_tb = 0;

#RST_DEASSERT_DLY;

#1 din_tb = 1;

@（posedge clk_tb）;

#1 din_tb = 0;

@（posedge clk_tb）;

#1 din_tb = 0;

@（posedge clk_tb）;

#1 din_tb = 1;

@（posedge clk_tb）;

#1 din_tb = 1;

@（posedge clk_tb）;

#1 din_tb = 0;

@（posedge clk_tb）;

#1 din_tb = 1;

@（posedge clk_tb）;

#1 din_tb = 1;

@（posedge clk_tb）;

#1 din_tb = 0;

end

initial begin

init_crc_tb = 0;

calc_crc_tb = 1;

end

CRC8_CCITT test_CRC8_CCITT

（.clk（clk_tb），.reset（reset_tb），

.din（din_tb），

.init_crc（init_crc_tb），

.calc_crc（calc_crc_tb），

.crc_out（crc_out_tb）

）;

endmodule

并行CRC计算

在前一部分，我们讨论了单比特输人数据的CRC计算方法。然而，在实际应用中，数据路径宽度通常为多比特的，并且每个时钟周期并行数据邡会改变。

例如，对于32位宽的并行数据，我们可以通过递归方法推导出32比特之后CRC寄存器的值。推导出来的每个32位并行CRC寄存器的输入值是当前输入datain［31:0］当前CRC寄存器的值crcreg组成的函数。

这一递归推导过程可以在理论上进行，但十分烦琐。Easics公司已经开发了网页版的工具（http://www.easics.com）/（https://www.easics.com/crctool/），设计者可以根据需要得到所需的计算公式。

部分数据CRC计算

我们讨论了串行数据的CRC计算，又讨论了使用递归方法计算并行数据的CRC在并行CRC计算时，如果最后一个输入数据中只有部分字节是有效的，那么应该怎么办呢？本部分将进行讨论。

以每个时钟周期到达8字节的PCle x8为例，在最后一个周期，有两种可能的情况，一种是所有8字节都是有效的，另一种是只有4字节32比特）是有效的。不携带有效数据的4字节由专用符号进行填充，称为PAD，PAD不参与CRC计算。

这意味着在前期每个时钟周期需要处理64比特数据，且需要在一个时钟周期内计算其CRC值。在最后一个周期中，CRC计算涉及所有8字节或只有4字节。此时，可以通过两种方式进行处理：

第一种方式是在一个计算CRC校验值的流水线中使用两个CRC校验计算电路，一个对64位数据进行计算，一个对32位数据进行计算，二者结合起来计算最后的CRC结果；第二种方式中只用一组CRC寄存器，但是，对于最后输入的并行数据，使用两个不同的电路计算CRC内部寄存器的输入值。这两种方式将在后面分别介绍。

流水线方式

这种机制需要两个CRC校验计算电路，一个用于每次计算64比特的CRC值，一个用于每次计算32比特的CRC值。

下面是具体内容：

使用一个64比特CRC计算电路和一个32比特CRC计算电路；

64比特CRC计算电路用于计算64位数据的CRC值；

对于最后一个并行数据，如果所有的8字节都是有效字节，则CRC校验结果由64比特CRC计算电路计算得到（32位的CRC计算电路在此次计算中没有起作用）；

如果最后一个数据中只有4字节是有效的，最终的CRC校验结果由32比特CRC计算电路计算得到；

在倒数第二个并行数据输入64比特CRC计算电路之后，64比特CRC计算电路中每个寄存器的输入值（注意，不是寄存器的输出值）被传递给32比特CRC计算电路，这样，当最后一组并行数据到达时，32位CRC计算电路的寄存器中存储的是来自于64位计算电路中前期计算的结果，该结果与当前数据一起进行32位并行计算，得到最终的校验结果。

仅使用一组CRC寄存器

在这种电路结构中，只使用一组CRC寄存器。

下面是其相关细节：

电路中有两个异或逻辑模块，第一个的输入是基于当前寄存器的值和64比特输入数据，第二个的输入是当前寄存器的值和32比特输入数据；

对于前面的数据，每个时钟周期内CRC计算电路使用64比特异或逻辑模块的输出结果；

对于最后一组数据，如果所有的8字节都有效，则使用64比特异或逻辑模块的计算结果作为最后一个时钟周期CRC寄存器的输入；如果只有4字节有效，则使用32比特异或逻辑模块的输出结果作为最后一个时钟周期CRC寄存器的输入。

从定时特性上看，使用流水线结构的并行CRC校验电路可以达到更高的速度，但它需要两组CRC寄存器。第二种方式仅需要一组CRC寄存器，但是其组合逻辑部分更为复杂，路径延迟更大，从而不利于提高处理速度。

下面是每个时钟周期计算64比特并行数据CRC校验结果的RTL代码，由Easics网站上的Web工具具计算得到。我们还可以生成32比特或者所需要的任何其他位宽的CRC并行计算电路。

// Copyright 2008 Altera Corporation. All rights reserved.

// Altera products are protected under numerous U.S. and foreign patents，

// maskwork rights， copyrights and other intellectual property laws.

//

// This reference design file， and your use thereof， is subject to and governed

// by the terms and conditions of the applicable Altera Reference Design

// License Agreement （either as signed by you or found at www.altera.com）。 By

// using this reference design file， you indicate your acceptance of such terms

// and conditions between you and Altera Corporation. In the event that you do

// not agree with such terms and conditions， you may not use the reference

// design file and please promptly destroy any copies you have made.

//

// This reference design file is being provided on an “as-is” basis and as an

// accommodation and therefore all warranties， representations or guarantees of

// any kind （whether express， implied or statutory） including， without

// limitation， warranties of merchantability， non-infringement， or fitness for

// a particular purpose， are specifically disclaimed. By making this reference

// design file available， Altera expressly does not recommend， suggest or

// require that this reference design file be used in combination with any

// other product not provided by Altera.

/////////////////////////////////////////////////////////////////////////////

//

// 24 bit CRC of 64 data bits （reversed - MSB first）

// polynomial ： 00328b63

// x^21 + x^20 + x^17 + x^15 + x^11 + x^9 + x^8 + x^6 + x^5 + x^1 + x^0

//

// CCCCCCCCCCCCCCCCCCCCCCCC DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

// 000000000011111111112222 0000000000111111111122222222223333333333444444444455555555556666

// 012345678901234567890123 0123456789012345678901234567890123456789012345678901234567890123

// C00 = .#.。。.#.##..##..#.###.## #..##.###.##..#.#.。。。。.#.。。。.####.#.####.#.。。.#.##..##..#.###.##

// C01 = ###.。.###.#.#.#.###..##. ##.#.##..##.#.####.。。。.##.。。.#.。.####.。.###.。.###.#.#.#.###..##.

// C02 = .###.。.###.#.#.#.###..## .##.#.##..##.#.####.。。。.##.。。.#.。.####.。.###.。.###.#.#.#.###..##

// C03 = 。.###.。.###.#.#.#.###..# 。.##.#.##..##.#.####.。。。.##.。。.#.。.####.。.###.。.###.#.#.#.###..#

// C04 = 。。.###.。.###.#.#.#.###.。 。。.##.#.##..##.#.####.。。。.##.。。.#.。.####.。.###.。.###.#.#.#.###.。

// C05 = ##..##..####.##.。。.#.#.# #..#.##.##.#.#.。。.####.#.。.########.#.。.##..##..####.##.。。.#.#.#

// C06 = 。.#..#..#.##.####.##.。.# ##.#.。。.##.##.。.#..######.。.#.。。.#.##.##..#..#..#.##.####.##.。.#

// C07 = #..#..#..#.##.####.##.。。 .##.#.。。.##.##.。.#..######.。.#.。。.#.##.##..#..#..#.##.####.##.。。

// C08 = #.。.#.#####.。。.#.#.#.### #.#.#####.。。.#..#.#..##.###..#.##.###..##.。.#.#####.。。.#.#.#.###

// C09 = #.。。.###..####.。。。.#.。。。 ##..##.。.###.。。.##.#..#..###.#.#.###..###.。。.###..####.。。。.#.。。。

// C10 = ##.。。.###..####.。。。.#.。。 .##..##.。.###.。。.##.#..#..###.#.#.###..###.。。.###..####.。。。.#.。。

// C11 = #.#.。.##.。。。。.###.###### #.#.#.。.#.#.###.#.##.#.##..##.#.####..###.#.。.##.。。。。.###.######

// C12 = ##.#.。.##.。。。。.###.##### .#.#.#.。.#.#.###.#.##.#.##..##.#.####..###.#.。.##.。。。。.###.#####

// C13 = ###.#.。.##.。。。。.###.#### 。.#.#.#.。.#.#.###.#.##.#.##..##.#.####..###.#.。.##.。。。。.###.####

// C14 = .###.#.。.##.。。。。.###.### 。。.#.#.#.。.#.#.###.#.##.#.##..##.#.####..###.#.。.##.。。。。.###.###

// C15 = .####.。.######..#.。。。。。。 #..#.。.#..###.。。.##.#.#..#.####.。。。。。。。。.####.。.######..#.。。。。。。

// C16 = 。.####.。.######..#.。。。。。 .#..#.。.#..###.。。.##.#.#..#.####.。。。。。。。。.####.。.######..#.。。。。。

// C17 = .#.###..####..###..##.## #.############..#..##.###..#.。。。。.#.####.#.###..####..###..##.##

// C18 = #.#.###..####..###..##.# .#.############..#..##.###..#.。。。。.#.####.#.###..####..###..##.#

// C19 = ##.#.###..####..###..##. 。.#.############..#..##.###..#.。。。。.#.####.#.###..####..###..##.

// C20 = #.#.#..#.#.#..#.##..#.。。 #.。.##.。.#..##.#.。.#..#..###.#.##.#.#.#.#.#.#..#.#.#..#.##..#.。。

// C21 = 。。.#.##..##..#.###.##### ##.###.##..#.#.。。。。.#.。。。.####.#.####.#.。。.#.##..##..#.###.#####

// C22 = 。。。.#.##..##..#.###.#### .##.###.##..#.#.。。。。.#.。。。.####.#.####.#.。。.#.##..##..#.###.####

// C23 = #.。。.#.##..##..#.###.### 。.##.###.##..#.#.。。。。.#.。。。.####.#.####.#.。。.#.##..##..#.###.###

//

// Number of XORs used is 24

// Total XOR inputs 1090

module crc24_dat64 （

input［23:0］ crc_in，

input［63:0］ dat_in，

output［23:0］ crc_out

）;

parameter METHOD = 1;

generate

if （METHOD == 0）

crc24_dat64_flat cc （.c（crc_in），.d（dat_in），.crc_out（crc_out））;

else

crc24_dat64_factor cc （.c（crc_in），.d（dat_in），.crc_out（crc_out））;

endgenerate

endmodule

module crc24_dat64_flat （c，d，crc_out）;

input［23:0］ c;

input［63:0］ d;

output［23:0］ crc_out;

wire［23:0］ crc_out;

assign crc_out［0］ =

c［1］ ^ c［6］ ^ c［8］ ^ c［9］ ^ c［12］ ^ c［13］ ^

c［16］ ^ c［18］ ^ c［19］ ^ c［20］ ^ c［22］ ^ c［23］ ^ d［63］ ^

d［62］ ^ d［60］ ^ d［59］ ^ d［58］ ^ d［56］ ^ d［53］ ^ d［52］ ^

d［49］ ^ d［48］ ^ d［46］ ^ d［41］ ^ d［39］ ^ d［38］ ^ d［37］ ^

d［36］ ^ d［34］ ^ d［32］ ^ d［31］ ^ d［30］ ^ d［29］ ^ d［23］ ^

d［16］ ^ d［14］ ^ d［11］ ^ d［10］ ^ d［8］ ^ d［7］ ^ d［6］ ^

d［4］ ^ d［3］ ^ d［0］;

assign crc_out［1］ =

c［0］ ^ c［1］ ^ c［2］ ^ c［6］ ^ c［7］ ^ c［8］ ^

c［10］ ^ c［12］ ^ c［14］ ^ c［16］ ^ c［17］ ^ c［18］ ^ c［21］ ^

c［22］ ^ d［62］ ^ d［61］ ^ d［58］ ^ d［57］ ^ d［56］ ^ d［54］ ^

d［52］ ^ d［50］ ^ d［48］ ^ d［47］ ^ d［46］ ^ d［42］ ^ d［41］ ^

d［40］ ^ d［36］ ^ d［35］ ^ d［34］ ^ d［33］ ^ d［29］ ^ d［24］ ^

d［23］ ^ d［17］ ^ d［16］ ^ d［15］ ^ d［14］ ^ d［12］ ^ d［10］ ^

d［9］ ^ d［6］ ^ d［5］ ^ d［3］ ^ d［1］ ^ d［0］;

assign crc_out［2］ =

c［1］ ^ c［2］ ^ c［3］ ^ c［7］ ^ c［8］ ^ c［9］ ^

c［11］ ^ c［13］ ^ c［15］ ^ c［17］ ^ c［18］ ^ c［19］ ^ c［22］ ^

c［23］ ^ d［63］ ^ d［62］ ^ d［59］ ^ d［58］ ^ d［57］ ^ d［55］ ^

d［53］ ^ d［51］ ^ d［49］ ^ d［48］ ^ d［47］ ^ d［43］ ^ d［42］ ^

d［41］ ^ d［37］ ^ d［36］ ^ d［35］ ^ d［34］ ^ d［30］ ^ d［25］ ^

d［24］ ^ d［18］ ^ d［17］ ^ d［16］ ^ d［15］ ^ d［13］ ^ d［11］ ^

d［10］ ^ d［7］ ^ d［6］ ^ d［4］ ^ d［2］ ^ d［1］;

assign crc_out［3］ =

c［2］ ^ c［3］ ^ c［4］ ^ c［8］ ^ c［9］ ^ c［10］ ^

c［12］ ^ c［14］ ^ c［16］ ^ c［18］ ^ c［19］ ^ c［20］ ^ c［23］ ^

d［63］ ^ d［60］ ^ d［59］ ^ d［58］ ^ d［56］ ^ d［54］ ^ d［52］ ^

d［50］ ^ d［49］ ^ d［48］ ^ d［44］ ^ d［43］ ^ d［42］ ^ d［38］ ^

d［37］ ^ d［36］ ^ d［35］ ^ d［31］ ^ d［26］ ^ d［25］ ^ d［19］ ^

d［18］ ^ d［17］ ^ d［16］ ^ d［14］ ^ d［12］ ^ d［11］ ^ d［8］ ^

d［7］ ^ d［5］ ^ d［3］ ^ d［2］;

assign crc_out［4］ =

c［3］ ^ c［4］ ^ c［5］ ^ c［9］ ^ c［10］ ^ c［11］ ^

c［13］ ^ c［15］ ^ c［17］ ^ c［19］ ^ c［20］ ^ c［21］ ^ d［61］ ^

d［60］ ^ d［59］ ^ d［57］ ^ d［55］ ^ d［53］ ^ d［51］ ^ d［50］ ^

d［49］ ^ d［45］ ^ d［44］ ^ d［43］ ^ d［39］ ^ d［38］ ^ d［37］ ^

d［36］ ^ d［32］ ^ d［27］ ^ d［26］ ^ d［20］ ^ d［19］ ^ d［18］ ^

d［17］ ^ d［15］ ^ d［13］ ^ d［12］ ^ d［9］ ^ d［8］ ^ d［6］ ^

d［4］ ^ d［3］;

assign crc_out［5］ =

c［0］ ^ c［1］ ^ c［4］ ^ c［5］ ^ c［8］ ^ c［9］ ^

c［10］ ^ c［11］ ^ c［13］ ^ c［14］ ^ c［19］ ^ c［21］ ^ c［23］ ^

d［63］ ^ d［61］ ^ d［59］ ^ d［54］ ^ d［53］ ^ d［51］ ^ d［50］ ^

d［49］ ^ d［48］ ^ d［45］ ^ d［44］ ^ d［41］ ^ d［40］ ^ d［36］ ^

d［34］ ^ d［33］ ^ d［32］ ^ d［31］ ^ d［30］ ^ d［29］ ^ d［28］ ^

d［27］ ^ d［23］ ^ d［21］ ^ d［20］ ^ d［19］ ^ d［18］ ^ d［13］ ^

d［11］ ^ d［9］ ^ d［8］ ^ d［6］ ^ d［5］ ^ d［3］ ^ d［0］;

assign crc_out［6］ =

c［2］ ^ c［5］ ^ c［8］ ^ c［10］ ^ c［11］ ^ c［13］ ^

c［14］ ^ c［15］ ^ c［16］ ^ c［18］ ^ c［19］ ^ c［23］ ^ d［63］ ^

d［59］ ^ d［58］ ^ d［56］ ^ d［55］ ^ d［54］ ^ d［53］ ^ d［51］ ^

d［50］ ^ d［48］ ^ d［45］ ^ d［42］ ^ d［39］ ^ d［38］ ^ d［36］ ^

d［35］ ^ d［33］ ^ d［28］ ^ d［24］ ^ d［23］ ^ d［22］ ^ d［21］ ^

d［20］ ^ d［19］ ^ d［16］ ^ d［12］ ^ d［11］ ^ d［9］ ^ d［8］ ^

d［3］ ^ d［1］ ^ d［0］;

assign crc_out［7］ =

c［0］ ^ c［3］ ^ c［6］ ^ c［9］ ^ c［11］ ^ c［12］ ^

c［14］ ^ c［15］ ^ c［16］ ^ c［17］ ^ c［19］ ^ c［20］ ^ d［60］ ^

d［59］ ^ d［57］ ^ d［56］ ^ d［55］ ^ d［54］ ^ d［52］ ^ d［51］ ^

d［49］ ^ d［46］ ^ d［43］ ^ d［40］ ^ d［39］ ^ d［37］ ^ d［36］ ^

d［34］ ^ d［29］ ^ d［25］ ^ d［24］ ^ d［23］ ^ d［22］ ^ d［21］ ^

d［20］ ^ d［17］ ^ d［13］ ^ d［12］ ^ d［10］ ^ d［9］ ^ d［4］ ^

d［2］ ^ d［1］;

assign crc_out［8］ =

c［0］ ^ c［4］ ^ c［6］ ^ c［7］ ^ c［8］ ^ c［9］ ^

c［10］ ^ c［15］ ^ c［17］ ^ c［19］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［59］ ^ d［57］ ^ d［55］ ^ d［50］ ^

d［49］ ^ d［48］ ^ d［47］ ^ d［46］ ^ d［44］ ^ d［40］ ^ d［39］ ^

d［36］ ^ d［35］ ^ d［34］ ^ d［32］ ^ d［31］ ^ d［29］ ^ d［26］ ^

d［25］ ^ d［24］ ^ d［22］ ^ d［21］ ^ d［18］ ^ d［16］ ^ d［13］ ^

d［8］ ^ d［7］ ^ d［6］ ^ d［5］ ^ d［4］ ^ d［2］ ^ d［0］;

assign crc_out［9］ =

c［0］ ^ c［5］ ^ c［6］ ^ c［7］ ^ c［10］ ^ c［11］ ^

c［12］ ^ c［13］ ^ c［19］ ^ d［59］ ^ d［53］ ^ d［52］ ^ d［51］ ^

d［50］ ^ d［47］ ^ d［46］ ^ d［45］ ^ d［40］ ^ d［39］ ^ d［38］ ^

d［35］ ^ d［34］ ^ d［33］ ^ d［31］ ^ d［29］ ^ d［27］ ^ d［26］ ^

d［25］ ^ d［22］ ^ d［19］ ^ d［17］ ^ d［16］ ^ d［11］ ^ d［10］ ^

d［9］ ^ d［5］ ^ d［4］ ^ d［1］ ^ d［0］;

assign crc_out［10］ =

c［0］ ^ c［1］ ^ c［6］ ^ c［7］ ^ c［8］ ^ c［11］ ^

c［12］ ^ c［13］ ^ c［14］ ^ c［20］ ^ d［60］ ^ d［54］ ^ d［53］ ^

d［52］ ^ d［51］ ^ d［48］ ^ d［47］ ^ d［46］ ^ d［41］ ^ d［40］ ^

d［39］ ^ d［36］ ^ d［35］ ^ d［34］ ^ d［32］ ^ d［30］ ^ d［28］ ^

d［27］ ^ d［26］ ^ d［23］ ^ d［20］ ^ d［18］ ^ d［17］ ^ d［12］ ^

d［11］ ^ d［10］ ^ d［6］ ^ d［5］ ^ d［2］ ^ d［1］;

assign crc_out［11］ =

c［0］ ^ c［2］ ^ c［6］ ^ c［7］ ^ c［14］ ^ c［15］ ^

c［16］ ^ c［18］ ^ c［19］ ^ c［20］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［60］ ^ d［59］ ^ d［58］ ^ d［56］ ^

d［55］ ^ d［54］ ^ d［47］ ^ d［46］ ^ d［42］ ^ d［40］ ^ d［39］ ^

d［38］ ^ d［35］ ^ d［34］ ^ d［33］ ^ d［32］ ^ d［30］ ^ d［28］ ^

d［27］ ^ d［24］ ^ d［23］ ^ d［21］ ^ d［19］ ^ d［18］ ^ d［16］ ^

d［14］ ^ d［13］ ^ d［12］ ^ d［10］ ^ d［8］ ^ d［4］ ^ d［2］ ^

d［0］;

assign crc_out［12］ =

c［0］ ^ c［1］ ^ c［3］ ^ c［7］ ^ c［8］ ^ c［15］ ^

c［16］ ^ c［17］ ^ c［19］ ^ c［20］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［60］ ^ d［59］ ^ d［57］ ^ d［56］ ^

d［55］ ^ d［48］ ^ d［47］ ^ d［43］ ^ d［41］ ^ d［40］ ^ d［39］ ^

d［36］ ^ d［35］ ^ d［34］ ^ d［33］ ^ d［31］ ^ d［29］ ^ d［28］ ^

d［25］ ^ d［24］ ^ d［22］ ^ d［20］ ^ d［19］ ^ d［17］ ^ d［15］ ^

d［14］ ^ d［13］ ^ d［11］ ^ d［9］ ^ d［5］ ^ d［3］ ^ d［1］;

assign crc_out［13］ =

c［0］ ^ c［1］ ^ c［2］ ^ c［4］ ^ c［8］ ^ c［9］ ^

c［16］ ^ c［17］ ^ c［18］ ^ c［20］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［60］ ^ d［58］ ^ d［57］ ^ d［56］ ^

d［49］ ^ d［48］ ^ d［44］ ^ d［42］ ^ d［41］ ^ d［40］ ^ d［37］ ^

d［36］ ^ d［35］ ^ d［34］ ^ d［32］ ^ d［30］ ^ d［29］ ^ d［26］ ^

d［25］ ^ d［23］ ^ d［21］ ^ d［20］ ^ d［18］ ^ d［16］ ^ d［15］ ^

d［14］ ^ d［12］ ^ d［10］ ^ d［6］ ^ d［4］ ^ d［2］;

assign crc_out［14］ =

c［1］ ^ c［2］ ^ c［3］ ^ c［5］ ^ c［9］ ^ c［10］ ^

c［17］ ^ c［18］ ^ c［19］ ^ c［21］ ^ c［22］ ^ c［23］ ^ d［63］ ^

d［62］ ^ d［61］ ^ d［59］ ^ d［58］ ^ d［57］ ^ d［50］ ^ d［49］ ^

d［45］ ^ d［43］ ^ d［42］ ^ d［41］ ^ d［38］ ^ d［37］ ^ d［36］ ^

d［35］ ^ d［33］ ^ d［31］ ^ d［30］ ^ d［27］ ^ d［26］ ^ d［24］ ^

d［22］ ^ d［21］ ^ d［19］ ^ d［17］ ^ d［16］ ^ d［15］ ^ d［13］ ^

d［11］ ^ d［7］ ^ d［5］ ^ d［3］;

assign crc_out［15］ =

c［1］ ^ c［2］ ^ c［3］ ^ c［4］ ^ c［8］ ^ c［9］ ^

c［10］ ^ c［11］ ^ c［12］ ^ c［13］ ^ c［16］ ^ d［56］ ^ d［53］ ^

d［52］ ^ d［51］ ^ d［50］ ^ d［49］ ^ d［48］ ^ d［44］ ^ d［43］ ^

d［42］ ^ d［41］ ^ d［30］ ^ d［29］ ^ d［28］ ^ d［27］ ^ d［25］ ^

d［22］ ^ d［20］ ^ d［18］ ^ d［17］ ^ d［12］ ^ d［11］ ^ d［10］ ^

d［7］ ^ d［3］ ^ d［0］;

assign crc_out［16］ =

c［2］ ^ c［3］ ^ c［4］ ^ c［5］ ^ c［9］ ^ c［10］ ^

c［11］ ^ c［12］ ^ c［13］ ^ c［14］ ^ c［17］ ^ d［57］ ^ d［54］ ^

d［53］ ^ d［52］ ^ d［51］ ^ d［50］ ^ d［49］ ^ d［45］ ^ d［44］ ^

d［43］ ^ d［42］ ^ d［31］ ^ d［30］ ^ d［29］ ^ d［28］ ^ d［26］ ^

d［23］ ^ d［21］ ^ d［19］ ^ d［18］ ^ d［13］ ^ d［12］ ^ d［11］ ^

d［8］ ^ d［4］ ^ d［1］;

assign crc_out［17］ =

c［1］ ^ c［3］ ^ c［4］ ^ c［5］ ^ c［8］ ^ c［9］ ^

c［10］ ^ c［11］ ^ c［14］ ^ c［15］ ^ c［16］ ^ c［19］ ^ c［20］ ^

c［22］ ^ c［23］ ^ d［63］ ^ d［62］ ^ d［60］ ^ d［59］ ^ d［56］ ^

d［55］ ^ d［54］ ^ d［51］ ^ d［50］ ^ d［49］ ^ d［48］ ^ d［45］ ^

d［44］ ^ d［43］ ^ d［41］ ^ d［39］ ^ d［38］ ^ d［37］ ^ d［36］ ^

d［34］ ^ d［27］ ^ d［24］ ^ d［23］ ^ d［22］ ^ d［20］ ^ d［19］ ^

d［16］ ^ d［13］ ^ d［12］ ^ d［11］ ^ d［10］ ^ d［9］ ^ d［8］ ^

d［7］ ^ d［6］ ^ d［5］ ^ d［4］ ^ d［3］ ^ d［2］ ^ d［0］;

assign crc_out［18］ =

c［0］ ^ c［2］ ^ c［4］ ^ c［5］ ^ c［6］ ^ c［9］ ^

c［10］ ^ c［11］ ^ c［12］ ^ c［15］ ^ c［16］ ^ c［17］ ^ c［20］ ^

c［21］ ^ c［23］ ^ d［63］ ^ d［61］ ^ d［60］ ^ d［57］ ^ d［56］ ^

d［55］ ^ d［52］ ^ d［51］ ^ d［50］ ^ d［49］ ^ d［46］ ^ d［45］ ^

d［44］ ^ d［42］ ^ d［40］ ^ d［39］ ^ d［38］ ^ d［37］ ^ d［35］ ^

d［28］ ^ d［25］ ^ d［24］ ^ d［23］ ^ d［21］ ^ d［20］ ^ d［17］ ^

d［14］ ^ d［13］ ^ d［12］ ^ d［11］ ^ d［10］ ^ d［9］ ^ d［8］ ^

d［7］ ^ d［6］ ^ d［5］ ^ d［4］ ^ d［3］ ^ d［1］;

assign crc_out［19］ =

c［0］ ^ c［1］ ^ c［3］ ^ c［5］ ^ c［6］ ^ c［7］ ^

c［10］ ^ c［11］ ^ c［12］ ^ c［13］ ^ c［16］ ^ c［17］ ^ c［18］ ^

c［21］ ^ c［22］ ^ d［62］ ^ d［61］ ^ d［58］ ^ d［57］ ^ d［56］ ^

d［53］ ^ d［52］ ^ d［51］ ^ d［50］ ^ d［47］ ^ d［46］ ^ d［45］ ^

d［43］ ^ d［41］ ^ d［40］ ^ d［39］ ^ d［38］ ^ d［36］ ^ d［29］ ^

d［26］ ^ d［25］ ^ d［24］ ^ d［22］ ^ d［21］ ^ d［18］ ^ d［15］ ^

d［14］ ^ d［13］ ^ d［12］ ^ d［11］ ^ d［10］ ^ d［9］ ^ d［8］ ^

d［7］ ^ d［6］ ^ d［5］ ^ d［4］ ^ d［2］;

assign crc_out［20］ =

c［0］ ^ c［2］ ^ c［4］ ^ c［7］ ^ c［9］ ^ c［11］ ^

c［14］ ^ c［16］ ^ c［17］ ^ c［20］ ^ d［60］ ^ d［57］ ^ d［56］ ^

d［54］ ^ d［51］ ^ d［49］ ^ d［47］ ^ d［44］ ^ d［42］ ^ d［40］ ^

d［38］ ^ d［36］ ^ d［34］ ^ d［32］ ^ d［31］ ^ d［29］ ^ d［27］ ^

d［26］ ^ d［25］ ^ d［22］ ^ d［19］ ^ d［15］ ^ d［13］ ^ d［12］ ^

d［9］ ^ d［5］ ^ d［4］ ^ d［0］;

assign crc_out［21］ =

c［3］ ^ c［5］ ^ c［6］ ^ c［9］ ^ c［10］ ^ c［13］ ^

c［15］ ^ c［16］ ^ c［17］ ^ c［19］ ^ c［20］ ^ c［21］ ^ c［22］ ^

c［23］ ^ d［63］ ^ d［62］ ^ d［61］ ^ d［60］ ^ d［59］ ^ d［57］ ^

d［56］ ^ d［55］ ^ d［53］ ^ d［50］ ^ d［49］ ^ d［46］ ^ d［45］ ^

d［43］ ^ d［38］ ^ d［36］ ^ d［35］ ^ d［34］ ^ d［33］ ^ d［31］ ^

d［29］ ^ d［28］ ^ d［27］ ^ d［26］ ^ d［20］ ^ d［13］ ^ d［11］ ^

d［8］ ^ d［7］ ^ d［5］ ^ d［4］ ^ d［3］ ^ d［1］ ^ d［0］;

assign crc_out［22］ =

c［4］ ^ c［6］ ^ c［7］ ^ c［10］ ^ c［11］ ^ c［14］ ^

c［16］ ^ c［17］ ^ c［18］ ^ c［20］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［60］ ^ d［58］ ^ d［57］ ^ d［56］ ^

d［54］ ^ d［51］ ^ d［50］ ^ d［47］ ^ d［46］ ^ d［44］ ^ d［39］ ^

d［37］ ^ d［36］ ^ d［35］ ^ d［34］ ^ d［32］ ^ d［30］ ^ d［29］ ^

d［28］ ^ d［27］ ^ d［21］ ^ d［14］ ^ d［12］ ^ d［9］ ^ d［8］ ^

d［6］ ^ d［5］ ^ d［4］ ^ d［2］ ^ d［1］;

assign crc_out［23］ =

c［0］ ^ c［5］ ^ c［7］ ^ c［8］ ^ c［11］ ^ c［12］ ^

c［15］ ^ c［17］ ^ c［18］ ^ c［19］ ^ c［21］ ^ c［22］ ^ c［23］ ^

d［63］ ^ d［62］ ^ d［61］ ^ d［59］ ^ d［58］ ^ d［57］ ^ d［55］ ^

d［52］ ^ d［51］ ^ d［48］ ^ d［47］ ^ d［45］ ^ d［40］ ^ d［38］ ^

d［37］ ^ d［36］ ^ d［35］ ^ d［33］ ^ d［31］ ^ d［30］ ^ d［29］ ^

d［28］ ^ d［22］ ^ d［15］ ^ d［13］ ^ d［10］ ^ d［9］ ^ d［7］ ^

d［6］ ^ d［5］ ^ d［3］ ^ d［2］;

endmodule

module crc24_dat64_factor （c，d，crc_out）;

input［23:0］ c;

input［63:0］ d;

output［23:0］ crc_out;

wire［23:0］ crc_out;

wire［114:0］ h ;

xor6 cx_0 （crc_out［0］， h［51］ ， h［60］ ， h［66］ ， h［73］ ， h［80］ ， h［93］）;

xor6 cx_1 （crc_out［1］， h［16］ ， h［37］ ， h［44］ ， h［61］ ， h［104］ ， h［114］）;

xor6 cx_2 （crc_out［2］， h［35］ ， h［36］ ， h［44］ ， h［57］ ， h［112］ ， h［113］）;

xor6 cx_3 （crc_out［3］， h［32］ ， h［35］ ， h［37］ ， h［40］ ， h［41］ ， h［111］）;

xor6 cx_4 （crc_out［4］， h［44］ ， h［46］ ， h［59］ ， h［65］ ， h［109］ ， h［110］）;

xor6 cx_5 （crc_out［5］， h［45］ ， h［46］ ， h［63］ ， h［64］ ， h［107］ ， h［108］）;

xor6 cx_6 （crc_out［6］， h［24］ ， h［34］ ， h［65］ ， h［67］ ， h［105］ ， h［106］）;

xor6 cx_7 （crc_out［7］， h［40］ ， h［49］ ， h［58］ ， h［67］ ， h［102］ ， h［103］）;

xor6 cx_8 （crc_out［8］， h［35］ ， h［39］ ， h［63］ ， h［66］ ， h［100］ ， h［101］）;

xor6 cx_9 （crc_out［9］， h［27］ ， h［45］ ， h［61］ ， h［66］ ， h［98］ ， h［99］）;

xor6 cx_10 （crc_out［10］， h［33］ ， h［44］ ， h［48］ ， h［95］ ， h［96］ ， h［97］）;

xor6 cx_11 （crc_out［11］， h［22］ ， h［33］ ， h［36］ ， h［49］ ， h［59］ ， h［94］）;

xor6 cx_12 （crc_out［12］， h［12］ ， h［44］ ， h［62］ ， h［90］ ， h［91］ ， h［92］）;

xor6 cx_13 （crc_out［13］， h［35］ ， h［38］ ， h［50］ ， h［64］ ， h［88］ ， h［89］）;

xor6 cx_14 （crc_out［14］， h［34］ ， h［50］ ， h［56］ ， h［62］ ， h［86］ ， h［87］）;

xor6 cx_15 （crc_out［15］， h［19］ ， h［38］ ， h［48］ ， h［55］ ， h［84］ ， h［85］）;

xor6 cx_16 （crc_out［16］， h［30］ ， h［38］ ， h［42］ ， h［54］ ， h［62］ ， h［83］）;

xor6 cx_17 （crc_out［17］， h［25］ ， h［31］ ， h［54］ ， h［66］ ， h［81］ ， h［82］）;

xor6 cx_18 （crc_out［18］， h［41］ ， h［55］ ， h［60］ ， h［63］ ， h［78］ ， h［79］）;

xor6 cx_19 （crc_out［19］， h［21］ ， h［28］ ， h［74］ ， h［75］ ， h［76］ ， h［77］）;

xor6 cx_20 （crc_out［20］， h［42］ ， h［45］ ， h［51］ ， h［57］ ， h［71］ ， h［72］）;

xor6 cx_21 （crc_out［21］， h［29］ ， h［56］ ， h［67］ ， h［68］ ， h［69］ ， h［70］）;

xor6 cx_22 （crc_out［22］， h［31］ ， h［37］ ， h［39］ ， h［52］ ， h［53］ ， h［58］）;

xor6 cx_23 （crc_out［23］， h［19］ ， h［23］ ， h［43］ ， h［47］ ， h［63］ ， h［73］）;

xor6 hx_0 （h［0］， c［19］ ， c［23］ ， d［63］ ， d［59］ ， d［36］ ， d［13］）; // used by 8

xor6 hx_1 （h［1］， c［16］ ， c［20］ ， d［60］ ， d［56］ ， d［36］ ， d［12］）; // used by 5

xor6 hx_2 （h［2］， c［17］ ， c［21］ ， d［61］ ， d［57］ ， d［35］ ， d［5］）; // used by 8

xor6 hx_3 （h［3］， c［9］ ， c［17］ ， d［57］ ， d［49］ ， d［37］ ， d［4］）; // used by 4

xor6 hx_4 （h［4］， c［9］ ， c［10］ ， d［50］ ， d［49］ ， d［11］ ， d［7］）; // used by 4

xor6 hx_5 （h［5］， c［5］ ， c［10］ ， c［11］ ， d［51］ ， d［50］ ， d［45］）; // used by 8

xor6 hx_6 （h［6］， c［0］ ， c［7］ ， d［47］ ， d［40］ ， d［34］ ， d［10］）; // used by 4

xor6 hx_7 （h［7］， c［6］ ， d［46］ ， d［39］ ， d［34］ ， d［8］ ， d［4］）; // used by 3

xor6 hx_8 （h［8］， c［18］ ， c［22］ ， d［62］ ， d［58］ ， d［16］ ， d［2］）; // used by 3

xor6 hx_9 （h［9］， c［0］ ， d［40］ ， d［29］ ， d［25］ ， d［22］ ， d［9］）; // used by 4

xor6 hx_10 （h［10］， c［12］ ， c［13］ ， d［53］ ， d［52］ ， d［29］ ， d［11］）; // used by 3

xor6 hx_11 （h［11］， c［1］ ， c［16］ ， c［22］ ， d［62］ ， d［56］ ， d［41］）; // used by 5

xor6 hx_12 （h［12］， c［15］ ， c［20］ ， d［60］ ， d［55］ ， d［39］ ， d［20］）; // used by 4

xor6 hx_13 （h［13］， c［8］ ， c［14］ ， d［54］ ， d［48］ ， d［23］ ， d［3］）; // used by 4

xor6 hx_14 （h［14］， c［2］ ， c［14］ ， d［54］ ， d［42］ ， d［38］ ， d［19］）; // used by 3

xor6 hx_15 （h［15］， c［4］ ， c［9］ ， d［49］ ， d［44］ ， d［21］ ， d［6］）; // used by 3

xor6 hx_16 （h［16］， c［6］ ， c［12］ ， d［52］ ， d［46］ ， d［24］ ， d［12］）; // used by 3

xor6 hx_17 （h［17］， c［1］ ， c［13］ ， d［53］ ， d［41］ ， d［30］ ， d［18］）; // used by 4

xor6 hx_18 （h［18］， c［18］ ， d［58］ ， d［37］ ， d［31］ ， d［30］ ， d［3］）; // used by 3

xor6 hx_19 （h［19］， c［8］ ， c［11］ ， c［12］ ， d［52］ ， d［51］ ， d［48］）; // used by 3

xor6 hx_20 （h［20］， c［16］ ， d［56］ ， d［33］ ， d［28］ ， d［8］ ， d［0］）; // used by 3

xor6 hx_21 （h［21］， c［3］ ， d［43］ ， d［38］ ， d［26］ ， d［18］ ， d［8］）; // used by 2

xor6 hx_22 （h［22］， c［23］ ， d［63］ ， d［32］ ， d［30］ ， d［23］ ， d［14］）; // used by 3

xor6 hx_23 （h［23］， c［7］ ， c［22］ ， d［62］ ， d［47］ ， d［29］ ， d［2］）; // used by 3

xor6 hx_24 （h［24］， c［19］ ， c［23］ ， d［63］ ， d［59］ ， d［35］ ， d［16］）; // used by 2

xor6 hx_25 （h［25］， c［3］ ， d［43］ ， d［34］ ， d［24］ ， d［11］ ， d［10］）; // used by 3

xor6 hx_26 （h［26］， d［38］ ， d［17］ ， d［9］ ， d［1］ ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_27 （h［27］， c［6］ ， c［19］ ， d［59］ ， d［46］ ， d［39］ ， d［17］）; // used by 2

xor6 hx_28 （h［28］， c［21］ ， d［61］ ， d［21］ ， d［15］ ， d［10］ ， d［6］）; // used by 2

xor6 hx_29 （h［29］， c［3］ ， d［43］ ， d［31］ ， d［26］ ， d［3］ ， d［1］）; // used by 1

xor6 hx_30 （h［30］， c［14］ ， d［54］ ， d［28］ ， d［23］ ， d［21］ ， d［1］）; // used by 1

xor6 hx_31 （h［31］， c［4］ ， d［44］ ， d［37］ ， d［27］ ， d［9］ ， d［6］）; // used by 2

xor6 hx_32 （h［32］， c［3］ ， c［4］ ， d［44］ ， d［43］ ， d［26］ ， d［17］）; // used by 1

xor6 hx_33 （h［33］， c［6］ ， c［20］ ， d［60］ ， d［46］ ， d［39］ ， d［27］）; // used by 3

xor6 hx_34 （h［34］， c［2］ ， d［42］ ， d［38］ ， d［24］ ， d［22］ ， d［21］）; // used by 2

xor6 hx_35 （h［35］， c［8］ ， d［48］ ， d［25］ ， d［18］ ， 1‘b0 ， 1’b0）; // used by 4

xor6 hx_36 （h［36］， c［15］ ， d［55］ ， d［35］ ， d［18］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_37 （h［37］， c［18］ ， d［58］ ， d［14］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 3

xor6 hx_38 （h［38］， c［2］ ， c［4］ ， d［44］ ， d［42］ ， 1’b0 ， 1‘b0）; // used by 3

xor6 hx_39 （h［39］， c［10］ ， d［50］ ， d［32］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_40 （h［40］， c［12］ ， d［52］ ， d［2］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_41 （h［41］， d［37］ ， d［8］ ， d［3］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_42 （h［42］， c［17］ ， d［57］ ， d［13］ ， d［4］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_43 （h［43］， d［15］ ， d［9］ ， h［0］ ， h［2］ ， h［18］ ， 1‘b0）; // used by 1

xor6 hx_44 （h［44］， d［17］ ， d［15］ ， d［6］ ， d［1］ ， 1’b0 ， 1‘b0）; // used by 5

xor6 hx_45 （h［45］， d［31］ ， d［27］ ， d［5］ ， d［0］ ， 1’b0 ， 1‘b0）; // used by 3

xor6 hx_46 （h［46］， d［32］ ， d［19］ ， d［9］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_47 （h［47］， c［5］ ， c［15］ ， d［55］ ， d［45］ ， d［38］ ， d［33］）; // used by 1

xor6 hx_48 （h［48］， d［28］ ， d［20］ ， d［12］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_49 （h［49］， d［24］ ， d［21］ ， d［13］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_50 （h［50］， c［1］ ， d［41］ ， d［26］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_51 （h［51］， c［9］ ， d［49］ ， d［32］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_52 （h［52］， h［1］ ， h［2］ ， h［7］ ， h［23］ ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_53 （h［53］， c［23］ ， d［63］ ， d［30］ ， d［28］ ， d［21］ ， d［1］）; // used by 1

xor6 hx_54 （h［54］， c［9］ ， d［49］ ， d［12］ ， d［8］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_55 （h［55］， c［16］ ， d［56］ ， d［25］ ， d［10］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_56 （h［56］， c［5］ ， c［22］ ， d［62］ ， d［45］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_57 （h［57］， c［7］ ， c［11］ ， d［51］ ， d［47］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_58 （h［58］， c［11］ ， c［14］ ， d［54］ ， d［51］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_59 （h［59］， c［19］ ， c［21］ ， d［61］ ， d［59］ ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_60 （h［60］， d［32］ ， d［30］ ， h［22］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_61 （h［61］， d［33］ ， d［9］ ， d［0］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_62 （h［62］， c［3］ ， d［43］ ， d［19］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 3

xor6 hx_63 （h［63］， c［0］ ， d［40］ ， d［28］ ， d［7］ ， 1’b0 ， 1‘b0）; // used by 4

xor6 hx_64 （h［64］， d［34］ ， d［29］ ， d［20］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 2

xor6 hx_65 （h［65］， c［13］ ， d［53］ ， d［36］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_66 （h［66］， d［38］ ， d［22］ ， d［16］ ， d［0］ ， 1’b0 ， 1‘b0）; // used by 4

xor6 hx_67 （h［67］， c［15］ ， d［55］ ， d［20］ ， d［1］ ， 1’b0 ， 1‘b0）; // used by 3

xor6 hx_68 （h［68］， h［0］ ， h［2］ ， h［4］ ， h［20］ ， 1’b0 ， 1‘b0）; // used by 1

xor6 hx_69 （h［69］， d［38］ ， d［34］ ， d［29］ ， d［27］ ， d［4］ ， d［1］）; // used by 1

xor6 hx_70 （h［70］， c［13］ ， d［53］ ， d［39］ ， d［27］ ， h［33］ ， 1’b0）; // used by 1

xor6 hx_71 （h［71］， h［9］ ， h［14］ ， 1‘b0 ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_72 （h［72］， c［4］ ， d［44］ ， d［34］ ， d［26］ ， d［15］ ， h［1］）; // used by 1

xor6 hx_73 （h［73］， d［22］ ， d［10］ ， d［6］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 2

xor6 hx_74 （h［74］， h［9］ ， h［11］ ， h［16］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_75 （h［75］， d［11］ ， d［7］ ， d［5］ ， d［4］ ， d［2］ ， h［5］）; // used by 1

xor6 hx_76 （h［76］， c［18］ ， d［58］ ， d［39］ ， d［36］ ， d［14］ ， d［13］）; // used by 1

xor6 hx_77 （h［77］， c［7］ ， c［13］ ， c［17］ ， d［57］ ， d［53］ ， d［47］）; // used by 1

xor6 hx_78 （h［78］， c［2］ ， d［42］ ， h［15］ ， h［16］ ， h［26］ ， 1‘b0）; // used by 1

xor6 hx_79 （h［79］， d［13］ ， d［11］ ， d［4］ ， h［2］ ， h［5］ ， h［12］）; // used by 1

xor6 hx_80 （h［80］， c［8］ ， c［19］ ， c［20］ ， d［60］ ， d［59］ ， d［48］）; // used by 1

xor6 hx_81 （h［81］， h［5］ ， h［11］ ， h［12］ ， h［13］ ， 1’b0 ， 1‘b0）; // used by 1

xor6 hx_82 （h［82］， d［19］ ， d［7］ ， d［5］ ， d［4］ ， d［2］ ， h［0］）; // used by 1

xor6 hx_83 （h［83］， d［31］ ， d［30］ ， d［26］ ， d［18］ ， h［5］ ， h［10］）; // used by 1

xor6 hx_84 （h［84］， d［3］ ， d［0］ ， h［4］ ， h［17］ ， 1’b0 ， 1‘b0）; // used by 1

xor6 hx_85 （h［85］， c［3］ ， d［43］ ， d［29］ ， d［27］ ， d［22］ ， d［17］）; // used by 1

xor6 hx_86 （h［86］， h［2］ ， h［4］ ， h［18］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_87 （h［87］， d［33］ ， d［27］ ， d［17］ ， d［16］ ， d［15］ ， h［0］）; // used by 1

xor6 hx_88 （h［88］， h［22］ ， h［28］ ， 1‘b0 ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_89 （h［89］， c［0］ ， d［40］ ， d［35］ ， h［1］ ， h［3］ ， h［8］）; // used by 1

xor6 hx_90 （h［90］， d［3］ ， h［0］ ， h［2］ ， h［9］ ， h［11］ ， 1‘b0）; // used by 1

xor6 hx_91 （h［91］， d［31］ ， d［28］ ， d［24］ ， d［14］ ， d［11］ ， d［6］）; // used by 1

xor6 hx_92 （h［92］， c［7］ ， c［8］ ， d［48］ ， d［47］ ， d［34］ ， d［33］）; // used by 1

xor6 hx_93 （h［93］， d［36］ ， d［7］ ， h［7］ ， h［10］ ， h［11］ ， h［18］）; // used by 1

xor6 hx_94 （h［94］， d［12］ ， d［4］ ， h［6］ ， h［8］ ， h［14］ ， h［20］）; // used by 1

xor6 hx_95 （h［95］， h［17］ ， h［19］ ， 1’b0 ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 1

xor6 hx_96 （h［96］， d［23］ ， d［15］ ， d［11］ ， d［5］ ， d［2］ ， h［6］）; // used by 1

xor6 hx_97 （h［97］， c［14］ ， d［54］ ， d［36］ ， d［35］ ， d［32］ ， d［26］）; // used by 1

xor6 hx_98 （h［98］， h［5］ ， h［6］ ， h［10］ ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_99 （h［99］， d［35］ ， d［26］ ， d［25］ ， d［19］ ， d［4］ ， d［1］）; // used by 1

xor6 hx_100 （h［100］， d［24］ ， h［0］ ， h［2］ ， h［7］ ， h［15］ ， h［23］）; // used by 1

xor6 hx_101 （h［101］， c［15］ ， d［55］ ， d［38］ ， d［31］ ， d［28］ ， d［26］）; // used by 1

xor6 hx_102 （h［102］， h［3］ ， h［9］ ， h［27］ ， 1‘b0 ， 1’b0 ， 1‘b0）; // used by 1

xor6 hx_103 （h［103］， d［24］ ， d［23］ ， d［11］ ， h［1］ ， h［25］ ， 1’b0）; // used by 1

xor6 hx_104 （h［104］， c［2］ ， c［10］ ， d［50］ ， d［42］ ， d［36］ ， d［29］）; // used by 1

xor6 hx_105 （h［105］， d［9］ ， h［5］ ， h［13］ ， h［20］ ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_106 （h［106］， c［18］ ， d［58］ ， d［39］ ， d［19］ ， d［12］ ， d［11］）; // used by 1

xor6 hx_107 （h［107］， h［0］ ， h［5］ ， h［13］ ， h［15］ ， h［17］ ， 1‘b0）; // used by 1

xor6 hx_108 （h［108］， c［21］ ， d［61］ ， d［33］ ， d［11］ ， d［8］ ， d［7］）; // used by 1

xor6 hx_109 （h［109］， d［1］ ， h［3］ ， h［5］ ， h［12］ ， h［21］ ， 1’b0）; // used by 1

xor6 hx_110 （h［110］， c［4］ ， d［44］ ， d［27］ ， d［13］ ， d［12］ ， d［3］）; // used by 1

xor6 hx_111 （h［111］， d［31］ ， d［5］ ， h［1］ ， h［4］ ， h［14］ ， h［24］）; // used by 1

xor6 hx_112 （h［112］， h［17］ ， h［25］ ， 1‘b0 ， 1’b0 ， 1‘b0 ， 1’b0）; // used by 1

xor6 hx_113 （h［113］， c［2］ ， d［42］ ， d［7］ ， h［0］ ， h［3］ ， h［8］）; // used by 1

xor6 hx_114 （h［114］， d［16］ ， h［2］ ， h［6］ ， h［11］ ， h［13］ ， 1‘b0）; // used by 1

endmodule

常用CRC类型PCIe：CRC16

用于链路层帧的校验；

多项式是100Bh（16，12，3，1，0）;

初始值是16’hFFFF;

发送电路中对计算结果（余数）取补，即在发送过程中进行比特取反；

接收电路比较本地计算的CRC结果与接收到的CRC结果，判断两者是否匹配，接收到的CRC不参与校验计算。

PCIe：CRC32

用于处理层数据包的校验；

多项式是04CllDB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’hFFFF_FFFF;

发送电路中对计算结果（余数）取补，即在发送过程中对比特取反；

接收电路比较本地计算的CRC结果与接收到的CRC结果，判断两者是否匹配，接收到的CRC不参与校验计算。

USB3.0：CRC16

用于USB3.0包头校验；

多项式是l00Bh（16，12，3，1，0）;

初始值是16’hFFFF;

在传输过程中对结果取补；

接收电路的余数是16’hFCAA;

接收的CRC值参与接收端的CRC计算。

关于和已知余数进行比较：

接收电路边接收数据边计算CRC校验值，如果接收数据中没有错误，则计算得到的余数为5’b0_100。将接收端的CRC计算结果和一个已知的值进行比较，比和接收的CRC进行比较要更加简单。在实际电路设计中，当接收到END符号时，电路内部产生end_pkt（包结束）信号，但此时接收数据中的CRC已经进入接收CRC计算电路中了，对于变长的数据包来说，预先知道接收的数据何时结束及接收包中CRC域何时开始是比较困难的。此时可以考虑使用多级移位寄存器对数据进行缓冲，然后得到新的start_pkt及end_pkt信号，并利用它们将接收数据域和接收的CRC域区分开。

USB2.0:CRC16

用于USB2.0数据传输；

多项式是8005h（16，15，2，0）;

初始值是16’hFFFF;

在发送过程中对计算结果进行取补；

接收电路的余数是16’h800D;

在接收端，接收到的CRC值包含在CRC计算中。

USB:CRC5

用于链路控制字段的校验；

多项式是05h（5，2，0）;

初始值是5’b1_lll;

在发送过程中对计算结果取补；

接收端的校验结果都是5’b0_l100;

接收的CRC值参与CRC计算；

接收电路将校验结果和5’b0_1100进行比较。

USB3.0:CRC32

用于USB3.0数据包传输；

多项式是04Cl_1DB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’hFFFF_FFFF;

发送电路在传输过程中对余数（校验结果）取补；

接收电路的校验余数是32’hC704_DD7B;

接收到的CRC值参与CRC计算；

接收电路将校验结果和32’hC704_DD7B进行比较。

SATA:CRC32

用于FIS（Frame Information Structure）包；

多项式是04C11DB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’h5232_5032;

发送电路对校验余数校验结果取补，在传输过程中，将1字节内的比特翻转；

接收电路的余数是16’h0000;

接收端，接收的CRC值参与校验运算，校验结果应该为全0。

关于实例整篇文章偏理论，计算实例可以通过（https://www.easics.com/crctool/）（可以直接得到Verilog源码）计算得到，当然还有一个脚本可以使用-任意多项式，任意位宽crc verilog代码自动生成perl脚本《https://cloud.tencent.com/developer/article/1652744》。

使用方法：

链接：https://pan.baidu.com/s/1pBlDHDxGRoXwyFKVuypR9A提取码：open

gen_crc.pl 输入数据位宽 多项式

多项式输入方法：从低位向高位依次输入，以USB TOKEN为例，x^5 + x^2 + 1，从低到高位输入为101001usb token的crc生成方法：gen_crc.pl 8 101001usb data的crc（x^16+x^15+x^2+1）生成方法：gen_crc.pl 8 10100000000000011

链接： https://pan.baidu.com/s/1kqRsSBJRq64tNnmv1SYjXQ

提取码： jr8i

说明：

windows下要安装ActivePerl。

1、在Windows上用ActivePerl写一个HelloWorld，测试完毕后，我们在C盘创建一个文件。

HelloWorld.pl

2、右键HelloWorld.pl文件 -》 用记事本打开该文件，然后输入以下代码：

#！/usr/bin/env perl

print “HelloWorld”

3、然后保存

4、回到cmd命令提示符。

cd

返回到C盘根目录

perl HelloWorld.pl

或者直接键入HelloWorld.pl

解释下：2行代码的作用

#！/usr/bin/env perl是典型的解释器路径声明（魔法声明），如果考虑到跨平台，在Unix/Linux上使用的，是必须要加上这个声明的，如果只是单纯的在windows上学习Perl，这个声明无关紧要。

print “HelloWorld”则是一条语句，作用就是在屏幕上输出一个字符串，“”内的则是字符串，例如小伙伴可以尝试修改“”内的内容。

Linux下就命令行perl perlname.pl

我是在虚拟机下运行的，所以无需安装特殊软件，直接perl gen_crc.pl 8 101001

就可以了。

编辑：jq