本文详细介绍了CRC校验的基本原理，包括模2运算和CRC校验码的生成过程。着重比较了并行实现的两种方法：通过模二除法和线性反馈移位寄存器(LFSR)。同时涵盖了如何处理串行数据，特别展示了LFSR在串行CRC中的简洁实现。
目录
我最推荐最后一种。
2.1并行实现 2.1.1模二除法实现CRC 2.1.2线性反馈移位寄存器LFSR实现CRC
2.2处理串行数据 2.2.1模二除法实现CRC 2.2.2线性反馈移位寄存器LFSR实现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多项式
多项式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
仿真结果（需要多次复位，把数据载入）：
还是多项式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
仿真结果正确，如图
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计算器验证正确
使用数据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计算(推荐使用)
参考资料
[2]模2运算
扫一扫
190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
