CRC（循環(huán)冗余校驗(yàn)）

CRC介紹

臨時(shí)“插播”，后面有實(shí)例。

CRC（Cyclic Redundancy Check，循環(huán)冗余校驗(yàn)）是數(shù)據(jù)幀傳輸中常用的一種差錯(cuò)控制編碼方式，針對(duì)要發(fā)送的數(shù)據(jù)幀，使用一些特定的多項(xiàng)式可以計(jì)算出CRC校驗(yàn)結(jié)果，CRC校驗(yàn)結(jié)果和原始數(shù)據(jù)一起傳輸?shù)浇邮斩恕?/p>

接收端在接收數(shù)據(jù)的同時(shí)按照相同的多項(xiàng)式對(duì)接收數(shù)據(jù)進(jìn)行校驗(yàn)運(yùn)算，并將校驗(yàn)結(jié)果和接收的結(jié)果進(jìn)行對(duì)比，如果二二者相同則認(rèn)為沒(méi)有發(fā)生傳輸錯(cuò)誤；如果不同，則認(rèn)為是發(fā)生了傳輸錯(cuò)誤。

從理論上說(shuō)，如果接收端計(jì)算出的CRC值與接收到的CRC值匹配，數(shù)據(jù)中仍有出錯(cuò)的可能，但由于這種可能性極低，在實(shí)際應(yīng)用中可以視為0，即沒(méi)有錯(cuò)誤出現(xiàn)。

當(dāng)接收端CRC不匹配時(shí)，接收端可以采取不同的措施，例如，丟棄數(shù)據(jù)包并通知對(duì)端，要求對(duì)端重新發(fā)送，或者只進(jìn)行丟棄處理，通過(guò)高層協(xié)議實(shí)現(xiàn)數(shù)據(jù)的重傳。

串行CRC計(jì)算

計(jì)算CRC步驟如下：

選擇一個(gè)CRC算法或生成多項(xiàng)式，如CRC8-CCITT的生成多項(xiàng)式表示為（x^8+x^2+x+1）;

CRC8硬件上由8個(gè)觸發(fā)器實(shí)現(xiàn)，整合為一個(gè)移位寄存器，稱為CRC寄存器。

計(jì)算CRC之前，CRC寄存器初始化為一個(gè)已知的值，稱為CRC初始值；這里要求確定的初始值，因?yàn)榻邮斩说腃RC校驗(yàn)電路需要使用和發(fā)送端相同的初始值；

CRC寄存器初始化之后，每個(gè)時(shí)鐘都有一個(gè)數(shù)據(jù)比特輸入，與當(dāng)前寄存器的值共同參與計(jì)算；CRC校驗(yàn)電路中，一些寄存器的輸入直接來(lái)自前級(jí)的輸出，有的是前級(jí)的輸出與當(dāng)前輸入數(shù)據(jù)進(jìn)行邏輯運(yùn)算的結(jié)果；

在每個(gè)周期，新的數(shù)據(jù)不斷輸入，CRC寄存器不斷更新，直到最后一個(gè)輸入比特到達(dá)；

當(dāng)最后一個(gè)數(shù)據(jù)比特到達(dá)時(shí)，CRC內(nèi)部所存儲(chǔ)的就是最后的CRC校驗(yàn)結(jié)果；

正如上面提到的，CRC校驗(yàn)結(jié)果的位寬取決于具體的CRC算法。例如，CRC5-USB中的CRC校驗(yàn)結(jié)果為5比特，CRC8-CCITT中CCRC校驗(yàn)結(jié)果為8比特；

在最后1個(gè)數(shù)據(jù)比特發(fā)出后，存儲(chǔ)在寄存器中的的CRC校驗(yàn)結(jié)果逐比特依次輸出，直至最后一個(gè)比特。可以看岀，校驗(yàn)結(jié)果緊跟在用戶數(shù)據(jù)后面輸出；

以下是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

測(cè)試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計(jì)算

在前一部分，我們討論了單比特輸人數(shù)據(jù)的CRC計(jì)算方法。然而，在實(shí)際應(yīng)用中，數(shù)據(jù)路徑寬度通常為多比特的，并且每個(gè)時(shí)鐘周期并行數(shù)據(jù)邡會(huì)改變。

例如，對(duì)于32位寬的并行數(shù)據(jù)，我們可以通過(guò)遞歸方法推導(dǎo)出32比特之后CRC寄存器的值。推導(dǎo)出來(lái)的每個(gè)32位并行CRC寄存器的輸入值是當(dāng)前輸入datain［31:0］當(dāng)前CRC寄存器的值crcreg組成的函數(shù)。

這一遞歸推導(dǎo)過(guò)程可以在理論上進(jìn)行，但十分煩瑣。Easics公司已經(jīng)開(kāi)發(fā)了網(wǎng)頁(yè)版的工具（http://www.easics.com）/（https://www.easics.com/crctool/），設(shè)計(jì)者可以根據(jù)需要得到所需的計(jì)算公式。

部分?jǐn)?shù)據(jù)CRC計(jì)算

我們討論了串行數(shù)據(jù)的CRC計(jì)算，又討論了使用遞歸方法計(jì)算并行數(shù)據(jù)的CRC在并行CRC計(jì)算時(shí)，如果最后一個(gè)輸入數(shù)據(jù)中只有部分字節(jié)是有效的，那么應(yīng)該怎么辦呢？本部分將進(jìn)行討論。

以每個(gè)時(shí)鐘周期到達(dá)8字節(jié)的PCle x8為例，在最后一個(gè)周期，有兩種可能的情況，一種是所有8字節(jié)都是有效的，另一種是只有4字節(jié)32比特）是有效的。不攜帶有效數(shù)據(jù)的4字節(jié)由專用符號(hào)進(jìn)行填充，稱為PAD，PAD不參與CRC計(jì)算。

這意味著在前期每個(gè)時(shí)鐘周期需要處理64比特?cái)?shù)據(jù)，且需要在一個(gè)時(shí)鐘周期內(nèi)計(jì)算其CRC值。在最后一個(gè)周期中，CRC計(jì)算涉及所有8字節(jié)或只有4字節(jié)。此時(shí)，可以通過(guò)兩種方式進(jìn)行處理：

第一種方式是在一個(gè)計(jì)算CRC校驗(yàn)值的流水線中使用兩個(gè)CRC校驗(yàn)計(jì)算電路，一個(gè)對(duì)64位數(shù)據(jù)進(jìn)行計(jì)算，一個(gè)對(duì)32位數(shù)據(jù)進(jìn)行計(jì)算，二者結(jié)合起來(lái)計(jì)算最后的CRC結(jié)果；第二種方式中只用一組CRC寄存器，但是，對(duì)于最后輸入的并行數(shù)據(jù)，使用兩個(gè)不同的電路計(jì)算CRC內(nèi)部寄存器的輸入值。這兩種方式將在后面分別介紹。

流水線方式

這種機(jī)制需要兩個(gè)CRC校驗(yàn)計(jì)算電路，一個(gè)用于每次計(jì)算64比特的CRC值，一個(gè)用于每次計(jì)算32比特的CRC值。

下面是具體內(nèi)容：

使用一個(gè)64比特CRC計(jì)算電路和一個(gè)32比特CRC計(jì)算電路；

64比特CRC計(jì)算電路用于計(jì)算64位數(shù)據(jù)的CRC值；

對(duì)于最后一個(gè)并行數(shù)據(jù)，如果所有的8字節(jié)都是有效字節(jié)，則CRC校驗(yàn)結(jié)果由64比特CRC計(jì)算電路計(jì)算得到（32位的CRC計(jì)算電路在此次計(jì)算中沒(méi)有起作用）；

如果最后一個(gè)數(shù)據(jù)中只有4字節(jié)是有效的，最終的CRC校驗(yàn)結(jié)果由32比特CRC計(jì)算電路計(jì)算得到；

在倒數(shù)第二個(gè)并行數(shù)據(jù)輸入64比特CRC計(jì)算電路之后，64比特CRC計(jì)算電路中每個(gè)寄存器的輸入值（注意，不是寄存器的輸出值）被傳遞給32比特CRC計(jì)算電路，這樣，當(dāng)最后一組并行數(shù)據(jù)到達(dá)時(shí)，32位CRC計(jì)算電路的寄存器中存儲(chǔ)的是來(lái)自于64位計(jì)算電路中前期計(jì)算的結(jié)果，該結(jié)果與當(dāng)前數(shù)據(jù)一起進(jìn)行32位并行計(jì)算，得到最終的校驗(yàn)結(jié)果。

僅使用一組CRC寄存器

在這種電路結(jié)構(gòu)中，只使用一組CRC寄存器。

下面是其相關(guān)細(xì)節(jié)：

電路中有兩個(gè)異或邏輯模塊，第一個(gè)的輸入是基于當(dāng)前寄存器的值和64比特輸入數(shù)據(jù)，第二個(gè)的輸入是當(dāng)前寄存器的值和32比特輸入數(shù)據(jù)；

對(duì)于前面的數(shù)據(jù)，每個(gè)時(shí)鐘周期內(nèi)CRC計(jì)算電路使用64比特異或邏輯模塊的輸出結(jié)果；

對(duì)于最后一組數(shù)據(jù)，如果所有的8字節(jié)都有效，則使用64比特異或邏輯模塊的計(jì)算結(jié)果作為最后一個(gè)時(shí)鐘周期CRC寄存器的輸入；如果只有4字節(jié)有效，則使用32比特異或邏輯模塊的輸出結(jié)果作為最后一個(gè)時(shí)鐘周期CRC寄存器的輸入。

從定時(shí)特性上看，使用流水線結(jié)構(gòu)的并行CRC校驗(yàn)電路可以達(dá)到更高的速度，但它需要兩組CRC寄存器。第二種方式僅需要一組CRC寄存器，但是其組合邏輯部分更為復(fù)雜，路徑延遲更大，從而不利于提高處理速度。

下面是每個(gè)時(shí)鐘周期計(jì)算64比特并行數(shù)據(jù)CRC校驗(yàn)結(jié)果的RTL代碼，由Easics網(wǎng)站上的Web工具具計(jì)算得到。我們還可以生成32比特或者所需要的任何其他位寬的CRC并行計(jì)算電路。

// 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

用于鏈路層幀的校驗(yàn)；

多項(xiàng)式是100Bh（16，12，3，1，0）;

初始值是16’hFFFF;

發(fā)送電路中對(duì)計(jì)算結(jié)果（余數(shù)）取補(bǔ)，即在發(fā)送過(guò)程中進(jìn)行比特取反；

接收電路比較本地計(jì)算的CRC結(jié)果與接收到的CRC結(jié)果，判斷兩者是否匹配，接收到的CRC不參與校驗(yàn)計(jì)算。

PCIe：CRC32

用于處理層數(shù)據(jù)包的校驗(yàn)；

多項(xiàng)式是04CllDB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’hFFFF_FFFF;

發(fā)送電路中對(duì)計(jì)算結(jié)果（余數(shù)）取補(bǔ)，即在發(fā)送過(guò)程中對(duì)比特取反；

接收電路比較本地計(jì)算的CRC結(jié)果與接收到的CRC結(jié)果，判斷兩者是否匹配，接收到的CRC不參與校驗(yàn)計(jì)算。

USB3.0：CRC16

用于USB3.0包頭校驗(yàn)；

多項(xiàng)式是l00Bh（16，12，3，1，0）;

初始值是16’hFFFF;

在傳輸過(guò)程中對(duì)結(jié)果取補(bǔ)；

接收電路的余數(shù)是16’hFCAA;

接收的CRC值參與接收端的CRC計(jì)算。

關(guān)于和已知余數(shù)進(jìn)行比較：

接收電路邊接收數(shù)據(jù)邊計(jì)算CRC校驗(yàn)值，如果接收數(shù)據(jù)中沒(méi)有錯(cuò)誤，則計(jì)算得到的余數(shù)為5’b0_100。將接收端的CRC計(jì)算結(jié)果和一個(gè)已知的值進(jìn)行比較，比和接收的CRC進(jìn)行比較要更加簡(jiǎn)單。在實(shí)際電路設(shè)計(jì)中，當(dāng)接收到END符號(hào)時(shí)，電路內(nèi)部產(chǎn)生end_pkt（包結(jié)束）信號(hào)，但此時(shí)接收數(shù)據(jù)中的CRC已經(jīng)進(jìn)入接收CRC計(jì)算電路中了，對(duì)于變長(zhǎng)的數(shù)據(jù)包來(lái)說(shuō)，預(yù)先知道接收的數(shù)據(jù)何時(shí)結(jié)束及接收包中CRC域何時(shí)開(kāi)始是比較困難的。此時(shí)可以考慮使用多級(jí)移位寄存器對(duì)數(shù)據(jù)進(jìn)行緩沖，然后得到新的start_pkt及end_pkt信號(hào)，并利用它們將接收數(shù)據(jù)域和接收的CRC域區(qū)分開(kāi)。

USB2.0:CRC16

用于USB2.0數(shù)據(jù)傳輸；

多項(xiàng)式是8005h（16，15，2，0）;

初始值是16’hFFFF;

在發(fā)送過(guò)程中對(duì)計(jì)算結(jié)果進(jìn)行取補(bǔ)；

接收電路的余數(shù)是16’h800D;

在接收端，接收到的CRC值包含在CRC計(jì)算中。

USB:CRC5

用于鏈路控制字段的校驗(yàn)；

多項(xiàng)式是05h（5，2，0）;

初始值是5’b1_lll;

在發(fā)送過(guò)程中對(duì)計(jì)算結(jié)果取補(bǔ)；

接收端的校驗(yàn)結(jié)果都是5’b0_l100;

接收的CRC值參與CRC計(jì)算；

接收電路將校驗(yàn)結(jié)果和5’b0_1100進(jìn)行比較。

USB3.0:CRC32

用于USB3.0數(shù)據(jù)包傳輸；

多項(xiàng)式是04Cl_1DB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’hFFFF_FFFF;

發(fā)送電路在傳輸過(guò)程中對(duì)余數(shù)（校驗(yàn)結(jié)果）取補(bǔ)；

接收電路的校驗(yàn)余數(shù)是32’hC704_DD7B;

接收到的CRC值參與CRC計(jì)算；

接收電路將校驗(yàn)結(jié)果和32’hC704_DD7B進(jìn)行比較。

SATA:CRC32

用于FIS（Frame Information Structure）包；

多項(xiàng)式是04C11DB7h（32，26，23，22，16，12，11，10，8，7，5，4，2，1，0）;

初始值是32’h5232_5032;

發(fā)送電路對(duì)校驗(yàn)余數(shù)校驗(yàn)結(jié)果取補(bǔ)，在傳輸過(guò)程中，將1字節(jié)內(nèi)的比特翻轉(zhuǎn)；

接收電路的余數(shù)是16’h0000;

接收端，接收的CRC值參與校驗(yàn)運(yùn)算，校驗(yàn)結(jié)果應(yīng)該為全0。

關(guān)于實(shí)例整篇文章偏理論，計(jì)算實(shí)例可以通過(guò)（https://www.easics.com/crctool/）（可以直接得到Verilog源碼）計(jì)算得到，當(dāng)然還有一個(gè)腳本可以使用-任意多項(xiàng)式，任意位寬crc verilog代碼自動(dòng)生成perl腳本《https://cloud.tencent.com/developer/article/1652744》。

使用方法：

鏈接：https://pan.baidu.com/s/1pBlDHDxGRoXwyFKVuypR9A提取碼：open

gen_crc.pl 輸入數(shù)據(jù)位寬 多項(xiàng)式

多項(xiàng)式輸入方法：從低位向高位依次輸入，以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

說(shuō)明：

windows下要安裝ActivePerl。

1、在Windows上用ActivePerl寫(xiě)一個(gè)HelloWorld，測(cè)試完畢后，我們?cè)贑盤(pán)創(chuàng)建一個(gè)文件。

HelloWorld.pl

2、右鍵HelloWorld.pl文件 -》 用記事本打開(kāi)該文件，然后輸入以下代碼：

#！/usr/bin/env perl

print “HelloWorld”

3、然后保存

4、回到cmd命令提示符。

cd

返回到C盤(pán)根目錄

perl HelloWorld.pl

或者直接鍵入HelloWorld.pl

解釋下：2行代碼的作用

#！/usr/bin/env perl是典型的解釋器路徑聲明（魔法聲明），如果考慮到跨平臺(tái)，在Unix/Linux上使用的，是必須要加上這個(gè)聲明的，如果只是單純的在windows上學(xué)習(xí)Perl，這個(gè)聲明無(wú)關(guān)緊要。

print “HelloWorld”則是一條語(yǔ)句，作用就是在屏幕上輸出一個(gè)字符串，“”內(nèi)的則是字符串，例如小伙伴可以嘗試修改“”內(nèi)的內(nèi)容。

Linux下就命令行perl perlname.pl

我是在虛擬機(jī)下運(yùn)行的，所以無(wú)需安裝特殊軟件，直接perl gen_crc.pl 8 101001

就可以了。

編輯：jq