一种自定产生CRC循环冗余校验码verilog程序简便方法。

目录

1.1CRC基本原理

1.2 实现方法

---

1.1CRC基本原理

       CRC（Cyclic Redundancy Check）是一种常用的错误检测码技术，用于检测数据传输过程中的错误。它通过添加一定数量的冗余位（校验码）到数据中，以便在接收端验证数据的完整性。以下是CRC的详细介绍：

基本原理：

1. 多项式编码： CRC基于多项式编码的原理。首先，选择一个固定的二进制多项式作为生成多项式。这个多项式称为CRC生成多项式，通常用一个二进制数来表示。生成多项式的系数决定了CRC校验码的长度和特性。

2. 冗余位生成： 数据发送方将待发送的数据当作一个多项式进行处理，并将生成多项式除以数据多项式。这个过程可以通过多项式的除法来实现，产生一个余数。这个余数被称为CRC校验码，它是一串二进制位，表示了数据多项式与生成多项式进行除法后的余数。

3. 附加冗余位： 在发送数据时，发送方会将CRC校验码附加到原始数据的末尾，形成一个新的数据帧。这个帧被传输到接收方。

4. 接收端处理： 在接收端，接收方接收到数据帧，并提取出数据部分和附加的CRC校验码。接收方再次对数据部分进行多项式除法，使用相同的生成多项式。如果除法的余数为零，表示数据在传输过程中没有出错；如果余数不为零，则表示数据可能出现错误。

5. 判定错误： 接收方对接收到的CRC校验码进行除法操作，得到余数。如果余数为零，则认为数据无错误；如果余数不为零，则判定数据可能出现了错误。

步骤：

1. 选择生成多项式： 首先，选择适当的生成多项式。生成多项式的选择决定了CRC校验码的长度和能力。

2. 数据处理： 将待发送的数据看作一个多项式，并进行多项式除法操作，得到CRC校验码。

3. 发送数据： 将原始数据和计算得到的CRC校验码组合成一个数据帧，并发送到接收端。

4. 接收数据： 接收方接收到数据帧，提取数据部分和附加的CRC校验码。

5. CRC校验： 接收方使用相同的生成多项式对接收到的数据部分进行多项式除法操作，得到余数。

6. 错误判断： 如果余数为零，则认为数据传输无错误。如果余数不为零，则认为数据可能出现了错误。

优势：

1. 高效性： CRC校验在检测数据传输错误方面非常高效，能够快速检测出错误的数据。

2. 简单实现： CRC的计算和校验过程相对简单，适用于硬件和软件实现。

3. 低复杂度： CRC校验相对于其他错误检测技术，具有较低的计算复杂度。

难点：

1. 冲突可能性： 尽管CRC可以有效地检测大多数错误，但在某些情况下，不同的错误可能会导致相同的CRC校验码，从而无法正确识别错误类型。

2. 校验长度选择： 选择适当的生成多项式和校验码长度是关键，不同的应用场景可能需要不同的设置。

1.2 实现方法

        循环冗余校验码（CRC），简称循环码，是一种常用的、具有检错、纠错能力的校验码，在早期的通信中运用广泛。循环冗余校验码常用于外存储器和计算机同步通信的数据校验。奇偶校验码和海明校验码都是采用奇偶检测为手段检错和纠错的(奇偶校验码不具有纠错能力)，而循环冗余校验则是通过某种数学运算来建立数据位和校验位的约定关系的。

        循环冗余校验码(cyclic redundancy check)简称CRC（循环码），是一种能力相当强的检错、纠错码，并且实现编码和检码的电路比较简单，常用于串行传送（二进制位串沿一条信号线逐位传送）的辅助存储器与主机的数据通信和计算机网络中。  
        循环码是指通过某种数学运算实现有效信息与校验位之间的循环校验（而海明码是一种多重校验）。 这种编码基本思想是将要传送的信息M(X)表示为一个多项式L，用L除以一个预先确定的多项式G(X)，得到的余式就是所需的循环冗余校验码。这种校验又称多项式校验。
        理论上可以证明循环冗余校验码的检错能力有以下特点：①可检测出所有奇数位错；②可检测出所有双比特的错；③可检测出所有小于、等于校验位长度的突发错。 
        循环冗余校验码由信息码n位和校验码k位构成。k位校验位拼接在n位数据位后面，n+k为循环冗余校验码的字长，又称这个校验码（n+k,n）码。n位信息位可以表示成为一个报文多项式M(x)，最高幂次是xn-1。约定的生成多项式G(x)是一个k+1位的二进制数，最高幂次是xk。将M(x)乘以xk，即左移k位后，除以G(x)，得到的k位余数就是校验位。这里的除法运算是模2除法，即当部分余数首位是1时商取1，反之商取0。然后每一位的减法运算是按位减，不产生借位。

        CRC码存储或传送后，在接收方进行校验过程，以判断数据是否有错，若有错则进行纠错。一个CRC码一定能被生成多项式整除，所以在接收方对码字用同样的生成多项式相除，如果余数为0，则码字没有错误；若余数不为0，则说明某位出错，不同的出错位置余数不同。对（n，k）码制，在生成多项式确定时，出错位置和余数的对应关系是确定的。

        在FPGA设计过程，如果需要设计CRC循环冗余校验码算法，我们可以借助如下网址进行快速设计：

OutputLogic.com » CRC Generator

打开之后，我们先设置输入数据位宽以及多项式宽度，其中也可以选择CRC的其他固定模式，如USB或者PCIe等等

然后选择step2： 

       点击多项式的参数，比如这里我们选择1，x5，x12，x14，最后点击产生verilog或者VHDL，就可以得到对应的程序，如下所示： 

// This source file may be used and distributed without restriction
// provided that this copyright statement is not removed from the file
// and that any derivative work contains the original copyright notice
// and the associated disclaimer.
//
// THIS SOURCE FILE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS
// OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
// WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//-----------------------------------------------------------------------------
// CRC module for data[31:0] ,   crc[15:0]=1+x^5+x^11+x^14+x^16;
//-----------------------------------------------------------------------------
module crc(
  input [31:0] data_in,
  input crc_en,
  output [15:0] crc_out,
  input rst,
  input clk);

  reg [15:0] lfsr_q,lfsr_c;

  assign crc_out = lfsr_q;

  always @(*) begin
    lfsr_c[0] = lfsr_q[1] ^ lfsr_q[3] ^ lfsr_q[6] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[0] ^ data_in[2] ^ data_in[4] ^ data_in[5] ^ data_in[6] ^ data_in[8] ^ data_in[9] ^ data_in[11] ^ data_in[13] ^ data_in[14] ^ data_in[17] ^ data_in[19] ^ data_in[22] ^ data_in[28] ^ data_in[29] ^ data_in[30] ^ data_in[31];
    lfsr_c[1] = lfsr_q[2] ^ lfsr_q[4] ^ lfsr_q[7] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[1] ^ data_in[3] ^ data_in[5] ^ data_in[6] ^ data_in[7] ^ data_in[9] ^ data_in[10] ^ data_in[12] ^ data_in[14] ^ data_in[15] ^ data_in[18] ^ data_in[20] ^ data_in[23] ^ data_in[29] ^ data_in[30] ^ data_in[31];
    lfsr_c[2] = lfsr_q[0] ^ lfsr_q[3] ^ lfsr_q[5] ^ lfsr_q[8] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[2] ^ data_in[4] ^ data_in[6] ^ data_in[7] ^ data_in[8] ^ data_in[10] ^ data_in[11] ^ data_in[13] ^ data_in[15] ^ data_in[16] ^ data_in[19] ^ data_in[21] ^ data_in[24] ^ data_in[30] ^ data_in[31];
    lfsr_c[3] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[4] ^ lfsr_q[6] ^ lfsr_q[9] ^ lfsr_q[15] ^ data_in[3] ^ data_in[5] ^ data_in[7] ^ data_in[8] ^ data_in[9] ^ data_in[11] ^ data_in[12] ^ data_in[14] ^ data_in[16] ^ data_in[17] ^ data_in[20] ^ data_in[22] ^ data_in[25] ^ data_in[31];
    lfsr_c[4] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[5] ^ lfsr_q[7] ^ lfsr_q[10] ^ data_in[4] ^ data_in[6] ^ data_in[8] ^ data_in[9] ^ data_in[10] ^ data_in[12] ^ data_in[13] ^ data_in[15] ^ data_in[17] ^ data_in[18] ^ data_in[21] ^ data_in[23] ^ data_in[26];
    lfsr_c[5] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[8] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[0] ^ data_in[2] ^ data_in[4] ^ data_in[6] ^ data_in[7] ^ data_in[8] ^ data_in[10] ^ data_in[16] ^ data_in[17] ^ data_in[18] ^ data_in[24] ^ data_in[27] ^ data_in[28] ^ data_in[29] ^ data_in[30] ^ data_in[31];
    lfsr_c[6] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[9] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[1] ^ data_in[3] ^ data_in[5] ^ data_in[7] ^ data_in[8] ^ data_in[9] ^ data_in[11] ^ data_in[17] ^ data_in[18] ^ data_in[19] ^ data_in[25] ^ data_in[28] ^ data_in[29] ^ data_in[30] ^ data_in[31];
    lfsr_c[7] = lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[10] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[2] ^ data_in[4] ^ data_in[6] ^ data_in[8] ^ data_in[9] ^ data_in[10] ^ data_in[12] ^ data_in[18] ^ data_in[19] ^ data_in[20] ^ data_in[26] ^ data_in[29] ^ data_in[30] ^ data_in[31];
    lfsr_c[8] = lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[11] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[3] ^ data_in[5] ^ data_in[7] ^ data_in[9] ^ data_in[10] ^ data_in[11] ^ data_in[13] ^ data_in[19] ^ data_in[20] ^ data_in[21] ^ data_in[27] ^ data_in[30] ^ data_in[31];
    lfsr_c[9] = lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[6] ^ lfsr_q[12] ^ lfsr_q[15] ^ data_in[4] ^ data_in[6] ^ data_in[8] ^ data_in[10] ^ data_in[11] ^ data_in[12] ^ data_in[14] ^ data_in[20] ^ data_in[21] ^ data_in[22] ^ data_in[28] ^ data_in[31];
    lfsr_c[10] = lfsr_q[5] ^ lfsr_q[6] ^ lfsr_q[7] ^ lfsr_q[13] ^ data_in[5] ^ data_in[7] ^ data_in[9] ^ data_in[11] ^ data_in[12] ^ data_in[13] ^ data_in[15] ^ data_in[21] ^ data_in[22] ^ data_in[23] ^ data_in[29];
    lfsr_c[11] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[3] ^ lfsr_q[7] ^ lfsr_q[8] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[15] ^ data_in[0] ^ data_in[2] ^ data_in[4] ^ data_in[5] ^ data_in[9] ^ data_in[10] ^ data_in[11] ^ data_in[12] ^ data_in[16] ^ data_in[17] ^ data_in[19] ^ data_in[23] ^ data_in[24] ^ data_in[28] ^ data_in[29] ^ data_in[31];
    lfsr_c[12] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[4] ^ lfsr_q[8] ^ lfsr_q[9] ^ lfsr_q[13] ^ lfsr_q[14] ^ data_in[1] ^ data_in[3] ^ data_in[5] ^ data_in[6] ^ data_in[10] ^ data_in[11] ^ data_in[12] ^ data_in[13] ^ data_in[17] ^ data_in[18] ^ data_in[20] ^ data_in[24] ^ data_in[25] ^ data_in[29] ^ data_in[30];
    lfsr_c[13] = lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[5] ^ lfsr_q[9] ^ lfsr_q[10] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[2] ^ data_in[4] ^ data_in[6] ^ data_in[7] ^ data_in[11] ^ data_in[12] ^ data_in[13] ^ data_in[14] ^ data_in[18] ^ data_in[19] ^ data_in[21] ^ data_in[25] ^ data_in[26] ^ data_in[30] ^ data_in[31];
    lfsr_c[14] = lfsr_q[1] ^ lfsr_q[4] ^ lfsr_q[10] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ data_in[0] ^ data_in[2] ^ data_in[3] ^ data_in[4] ^ data_in[6] ^ data_in[7] ^ data_in[9] ^ data_in[11] ^ data_in[12] ^ data_in[15] ^ data_in[17] ^ data_in[20] ^ data_in[26] ^ data_in[27] ^ data_in[28] ^ data_in[29] ^ data_in[30];
    lfsr_c[15] = lfsr_q[0] ^ lfsr_q[2] ^ lfsr_q[5] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[1] ^ data_in[3] ^ data_in[4] ^ data_in[5] ^ data_in[7] ^ data_in[8] ^ data_in[10] ^ data_in[12] ^ data_in[13] ^ data_in[16] ^ data_in[18] ^ data_in[21] ^ data_in[27] ^ data_in[28] ^ data_in[29] ^ data_in[30] ^ data_in[31];

  end // always

  always @(posedge clk, posedge rst) begin
    if(rst) begin
      lfsr_q <= {16{1'b1}};
    end
    else begin
      lfsr_q <= crc_en ? lfsr_c : lfsr_q;
    end
  end // always
endmodule // crc

最后，我们只要自己再写一个简单的testbench文件就可以使用CRC了。