目录

我最推荐最后一种。

1、CRC原理

2.实现CRC校验的四种程序

2.1并行实现   2.1.1模二除法实现CRC   2.1.2线性反馈移位寄存器LFSR实现CRC

2.2处理串行数据   2.2.1模二除法实现CRC   2.2.2线性反馈移位寄存器LFSR实现CRC

1、CRC原理

模2运算原理

模2加法：不考虑进位，按位加=按位异或---等价于---模2减法：不考虑借位，按位减=按位异或
模2乘法：在将各个位乘的结果相加时按照模2加法来做
模2除法：每一步商1后，减法使用的是模2减法
下面的模2除法参考[1]：

      1 0 1 1     //商

---------------

1 1 1 1 0 0 0     //被除数,注意首位为1

1 1 0 1           //被除数首位为1,除以除数

---------------

  0 1 0 0 0 0     //余数去掉首位,作为新的被除数

  0 0 0 0         //被除数首位为0,除以0，商的第二位为0

---------------

    1 0 0 0 0     //余数去掉首位,作为新的被除数

    1 1 0 1       //被除数首位为1,除以除数 

---------------

      1 0 1 0     //余数去掉首位,作为新的被除数

      1 1 0 1     //被除数首位为1,除以除数

---------------

      0 1 1 1     //余数,此时余数位数少于除数,不能继续除了(忽略首位0)

CRC校验码的工作原理：将所要传输的信息称为被除数，模2除以一个收发双方都知道的特定的除数，将得到的余数拼接到被除数尾部，然后发送这个拼接后的数，接收方收到这个数后同样除以除数，如果收到的信息正确那么余数应该为0，否则收到的信息是错误的。所以称为CRC有校验（检错）的功能，但不能纠错。

上述中得到的余数称为CRC冗余校验码。

上述特定的除数都是有标准的，一般用生成多项式表示，且多项式是有标准的，生成多项式的选取是个很有难度的问题，如果选的不好，那么检出错误的概率就会低很多。好在这个问题已经被专家们研究了很长一段时间了，对于我们这些使用者来说，只要把现成的成果拿来用就行了。例如：

图1 常见的CRC多项式

 

2.实现CRC校验的四种程序

2.1并行实现

2.1.1模二除法实现CRC

多项式CRC=x16+x12+x5+x0，若使用CRC（循环冗余校验）在线计算，注意应该选择CRC-16/XMODEN，而不是CRC-16/CCITT，如图2，按照原理其输入值不反转即FALSE，输出值也是。（我找到的程序是这样实现的，我开始选择的时候选错了选的CRC-16/CCITT，导致在线计算结果与程序结果不一致而怀疑人生，还是粗心哈哈）

图2 同一种多项式有多种使用方法

下面是Verilog代码，其是对输入的并行数据进行计算CRC，但是用的是时序串行计算的方法，需要8个clk才计算出结果。

/*************************按照原理实现方法**************************/

module CRC_Gen(

    input clk,

    input rst_n,

    input [7:0] data,

    input data_valid,

    output reg [15:0] crc

    );

   

    reg[23:0]temp=0;

    parameter polynomial=17'b1_0001_0000_0010_0001;

   

   

 always @ (posedge clk or negedge rst_n)

 begin

    if(!rst_n)

    begin

        crc<=0;

        temp<={data,16'b0};//复位时，将初始数据放入寄存器

    end

    else if(data_valid)

    begin

             if(temp[23]) temp[23:7]<=temp[23:7]^polynomial;

        else if(temp[22]) temp[22:6]<=temp[22:6]^polynomial;

        else if(temp[21]) temp[21:5]<=temp[21:5]^polynomial;

        else if(temp[20]) temp[20:4]<=temp[20:4]^polynomial;

        else if(temp[19]) temp[19:3]<=temp[19:3]^polynomial;

        else if(temp[18]) temp[18:2]<=temp[18:2]^polynomial;

        else if(temp[17]) temp[17:1]<=temp[17:1]^polynomial;

        else if(temp[16]) temp[16:0]<=temp[16:0]^polynomial;

        else   crc<=temp[15:0];  

    end  

 end

      

endmodule

 

/***********************testbench******************************/

module CRC_Gen_tb;

 

reg clk;

reg rst_n;

reg [7:0]data;

reg data_valid;

 

wire [15:0]crc;

 

initial

begin

    clk=0;

    rst_n=0;

    data=8'b10110110;data_valid=1;//复位时，将初始数据放入寄存器

    #100 rst_n=1;

  

    #500 rst_n =0;

    data =8'b01001100; data_valid=1;

    #300 rst_n =1;

  

    #500 rst_n =0;

    data =8'b10110011;data_valid=1;

    #300 rst_n =1;

  

    #500 rst_n =0;

    data =8'b01001001; data_valid=1;    

    #300 rst_n =1;

   

    #500 rst_n =0;

    data =8'b10101010;data_valid=1;

    #300 rst_n =1;

end

 

 CRC_Gen   U0(

   .clk(clk),

   .rst_n(rst_n),

   .data(data),

   .data_valid(data_valid),

   .crc(crc)

    );

endmodule

仿真结果（需要多次复位，把数据载入）：

2.1.2线性反馈移位寄存器LFSR实现CRC

还是多项式CRC=x16+x12+x5+x0，对应如图3，至于为什么这么实现，大概可以理解为把输出输出每一位拆开计算，其中的推导比较复杂(我看了好久看的不是很懂，最后得出一个结论，就是记住结论即可哈哈)。

图3

输入数据是并行的，以下做到了在一个时钟周期内算出CRC校验码[3]。

参考来自基于FPGA的CRC校验码生成器。如果用时序电路串行实现，则8 bit数据要移位8次，就需要8个clk，效率低下，为了能在一个时钟周期输出结果，必须采用组合电路，当然，这是以空间换时间的方法，由于使用了for循环8次，直观的讲电路规模将扩大8倍。for语句循环几次，就是将相同的电路复制几次，因此循环次数越多，占用面积越大。

/*************************LFSR实现方法**************************/

module CRC_Gen(

    input            rst_n,     /*async reset,active low*/

    input            clk,     /*clock input*/

    input     [7:0]  data, /*parallel data input pins */

    input            data_valid, /* data valid,start to generate CRC, active high*/

    output reg[15:0] crc

);

 

integer i;

reg feedback;

reg [15:0] crc_tmp;

/*

*　　sequential process

*/

always @(posedge clk or negedge rst_n)

begin

    if(!rst_n)

        crc <= 16'b0;          /*触发器中的初始值十分重要 */

    else if(data_valid==1'b0)

        crc <= 16'b0;

    else

        crc <= crc_tmp;

end

 

/*

*   combination process

*/

always@( data or crc)

begin

    crc_tmp = crc;

    for(i=7; i>=0; i=i-1)

    begin

        feedback    = crc_tmp[15] ^ data[i];

        crc_tmp[15]  = crc_tmp[14];

        crc_tmp[14]  = crc_tmp[13];

        crc_tmp[13]  = crc_tmp[12];

        crc_tmp[12]  = crc_tmp[11] ^ feedback;

        crc_tmp[11]  = crc_tmp[10] ;

        crc_tmp[10]  = crc_tmp[9];

        crc_tmp[9]   = crc_tmp[8];

        crc_tmp[8]   = crc_tmp[7];

        crc_tmp[7]   = crc_tmp[6];

        crc_tmp[6]   = crc_tmp[5];

        crc_tmp[5]   = crc_tmp[4] ^ feedback;

        crc_tmp[4]   = crc_tmp[3];

        crc_tmp[3]   = crc_tmp[2];

        crc_tmp[2]   = crc_tmp[1];

        crc_tmp[1]   = crc_tmp[0];

        crc_tmp[0]   = feedback;

     end

end

 

endmodule

 

/************************testbench**************************/

initial

begin

    clk=0;

    rst_n=0;

    data=8'b0;

    data_valid=0;

    #100 rst_n=1;

    data =8'b10110110;      data_valid=1;#10 data_valid=0;

    #100 data =8'b01001100; data_valid=1;#10 data_valid=0;

    #100 data =8'b10110011; data_valid=1;#10 data_valid=0;

    #100 data =8'b01001001; data_valid=1;#10 data_valid=0;     

    #100 data =8'b10101010; data_valid=1;#10 data_valid=0;

end

 

always #5 clk=~clk;

 

 CRC_Gen   U0(

   .clk(clk),

   .rst_n(rst_n),

   .data(data),

   .data_valid(data_valid),

   .crc(crc)

    );

endmodule

仿真结果正确，如图

2.2处理串行数据

2.2.1模二除法实现CRC

1）使用定义实现CRC代码，使用数据32'b96E32077,第一个always将数据串行化，第二个always里面进行CRC模二除法运算。

module CRC_GenSerial(

   input clk,

   input rst_n,

   output [15:0] crc

    );

   

    reg [31:0]data_parallel;

    reg data_serial;

    reg [5:0]cnt;

   

    reg [16:0]tmpcrc;

   

    parameter source_data=32'h96E32077;

    parameter polynomial=17'b1_0001_0000_0010_0001;

 

   assign crc=tmpcrc[15:0];

   

always @ (posedge clk or negedge rst_n)

begin

    if(!rst_n)

    begin

        data_parallel<=source_data;

        data_serial<=0;

    end

    else if(cnt<32)

    begin

        data_serial<=data_parallel[31];

        data_parallel<=data_parallel<<1;   

    end

    else

    begin

        data_serial<=0;

        data_parallel<=0;

    end

end

 

always @ (posedge clk or negedge rst_n)

begin

    if(!rst_n)

    begin

       tmpcrc<=0;

       cnt<=0; 

    end

    else

    begin

       

        if(cnt<=16) //17bit then xor

        begin

            cnt<=cnt+1;

            tmpcrc<={tmpcrc[15:0],data_serial};

        end

        else if((cnt>=17)&&(cnt<=32))

        begin

            cnt<=cnt+1;

            if(tmpcrc[15]) // if =1 XOR polynomial

                tmpcrc<={tmpcrc[15:0],data_serial}^polynomial;

            else           // if =0 XOR 0

                tmpcrc<={tmpcrc[15:0],data_serial};

        end

        else if((cnt>=33)&&(cnt<=48)) //add 0 at tail

        begin

           cnt<=cnt+1;

           if(tmpcrc[15])

                tmpcrc<={tmpcrc[15:0],1'b0}^polynomial;

           else

                tmpcrc<={tmpcrc[15:0],1'b0};

        end

        else

        begin

           cnt<=cnt;

           tmpcrc<=tmpcrc;

        end          

    end

end  

  

endmodule

定义实现串行数据的CRC校验结果

使用CRC计算器验证正确

2.2.2线性反馈移位寄存器LFSR实现CRC

使用数据32'b96E32077,第一个always将数据串行化，第二个always里面使用LFSR，更简洁明了。注意cnt值的控制。

module CRC_GenSerial(

   input clk,

   input rst_n,

   output reg [15:0] crc

    );

   

    reg [31:0]data_parallel;

    reg data_serial;

    reg [5:0]cnt;

   

    parameter source_data=32'h96E32077;

   

always @ (posedge clk or negedge rst_n)

begin

    if(!rst_n)

    begin

        cnt<=0;

        data_parallel<=source_data;

        data_serial<=0;

    end

    else if(cnt<32)

    begin

        cnt<=cnt+1;

        data_serial<=data_parallel[31];

        data_parallel<=data_parallel<<1;   

    end

    else

    begin

        cnt<=33;

        data_serial<=0;

        data_parallel<=0;

    end

end

 

always @ (posedge clk or negedge rst_n)

begin

    if(!rst_n)

    begin

        crc<=0;

    end

    else if(cnt<=32)

    begin

        crc[0]<=crc[15]^data_serial;

        crc[4:1]<=crc[3:0];

        crc[5]<=crc[4]^crc[15]^data_serial;

        crc[11:6]<=crc[10:5];

        crc[12]<=crc[11]^crc[15]^data_serial;

        crc[15:13]<=crc[14:12];

    end

    else

        crc<=crc;  

end  

  

endmodule

使用LFSR实现串行数据的CRC计算(推荐使用)

参考资料

[1]模2除法(CRC校验码计算)

[2]模2运算

[3]CRC算法原理及其Verilog实现