十六、基于FPGA的CRC校验设计实现

这篇具有很好参考价值的文章主要介绍了十六、基于FPGA的CRC校验设计实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1,CRC校验

循环冗余校验(Cyclic Redundancy Check, CRC)是一种根据网络数据包或计算机文件等数据产生简短固定位数校验码的一种信道编码技术,主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理来作错误侦测的。

2,CRC 多项式

多项式一般指输入数据异或的对象;其中相关参数还包括:初值,结果异或值,输入翻转,输出翻转。

初始值:计算之前给CRC赋初始值;

结果异或值:计算完CRC输出前;对CRC结果异或的参数值;

输入值反转:输入翻转指对输入输入按字节翻转;

输出值反转:对输出结果在CRC计算之后,异或之前整体翻转

一般常用的CRC多项式如下:

十六、基于FPGA的CRC校验设计实现

3 CRC逻辑设计实现

设计实现CRC-8 CRC-16 CRC-32位校验计算;下面分别介绍串行,并行的不同实现思路;

3.1 CRC串行实现

实现流程:

a, 输入数据 翻转控制;

b, 翻转后数据与CRC初值异或;8位直接异或;16位与32位先异或高8位;

c, 循环左移异或计算;8位左移8次;16位左移16次;32位左移32次;

16位;在左移8次后需要用异或结果的高8位异或原始数据的低8位;然后在继续左移运算

32位;在左移8,16,24位后用异或结果的高8位异或原始数据的次高8位,次低8位,低8位,然后再继续左移运算;

d, 对计算的CRC结果进行翻转处理;

e, 对输出的翻转数据进行异或数据处理;输出

(1)CRC-8位实现
module crc_8 #(
    parameter [7:0] CRC8_PARAM = 8'h07,//多项式
    parameter [7:0] CRC_INIT = 8'h00,
    parameter [7:0] DATA_XOROUT = 8'h55
)(
    input sys_clk,
    input sys_rst,
    input in_swap_en,
    input out_swap_en,
    input data_in_en,
    input [7:0] data_in,
    output data_out_en,
    output [7:0] data_out
 );
    
    wire [7:0] swap_data;
    reg [7:0] crc_reg = CRC_INIT;
    reg [7:0] crc_cnt = 0;
    reg data_out_en_reg = 0;
    reg [7:0] data_out_reg = 0;

    assign swap_data = in_swap_en ? {data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]}:data_in;
                              
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin 
            crc_reg <= CRC_INIT;
            crc_cnt <= 0;
            end 
        else if(data_in_en && crc_cnt == 0) begin 
            crc_reg <= swap_data^crc_reg; 
            crc_cnt <= 1; 
            end 
        else if(crc_cnt == 9) begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
        else if(crc_cnt !=0) begin 
            crc_reg <= (crc_reg[7] == 0 ? crc_reg << 1 : (crc_reg << 1 ^ CRC8_PARAM));
            crc_cnt <= crc_cnt + 1;
            end 
        else begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
    end    
    
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin
            data_out_en_reg <= 0;
            data_out_reg <= 0;
            end 
        else if(crc_cnt == 9) begin 
            data_out_en_reg <= 1;
            data_out_reg <= out_swap_en ? {crc_reg[0],crc_reg[1],crc_reg[2],crc_reg[3],crc_reg[4],crc_reg[5],crc_reg[6],crc_reg[7]}:crc_reg;
            end 
        else begin 
            data_out_en_reg <= 0;
            data_out_reg <= data_out_reg;
            end 
    end     
    
    assign data_out_en = data_out_en_reg;
    assign data_out = data_out_reg ^ DATA_XOROUT;
    
endmodule
(2)CRC-16位实现
module crc_16 #(
    parameter [15:0] CRC16_PARAM = 16'h8005,
    parameter [15:0] CRC_INIT = 16'h0000,
    parameter [15:0] DATA_XOROUT = 16'hFFFF
)(
    input sys_clk,
    input sys_rst,
    input in_swap_en,
    input out_swap_en,
    input data_in_en,
    input [15:0] data_in,
    output data_out_en,
    output [15:0] data_out
 );
    
    wire [15:0] swap_data;
    reg [15:0] crc_reg = CRC_INIT;
    reg [7:0] crc_cnt = 0;
    reg data_out_en_reg = 0;
    reg [15:0] data_out_reg = 0;

    assign swap_data = in_swap_en ? {data_in[8],data_in[9],data_in[10],data_in[11],data_in[12],data_in[13],data_in[14],data_in[15],                                 
                                 data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]}:data_in;
                              
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin 
            crc_reg <= CRC_INIT;
            crc_cnt <= 0;
            end 
        else if(data_in_en && crc_cnt == 0) begin 
            crc_reg <={swap_data[15:8]^crc_reg[15:8],crc_reg[7:0]}; 
            crc_cnt <= 1; 
            end 
        else if(crc_cnt == 9) begin 
            crc_reg <={swap_data[7:0]^crc_reg[15:8],crc_reg[7:0]}; 
            crc_cnt <= crc_cnt + 1; 
            end 
        else if(crc_cnt == 18) begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
        else if(crc_cnt !=0) begin// && shift_en == 0) begin 
            crc_reg <= (crc_reg[15] == 0 ? crc_reg << 1 : (crc_reg << 1 ^ CRC16_PARAM));
            crc_cnt <= crc_cnt + 1;
            end 
        else begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
    end                        
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin
            data_out_en_reg <= 0;
            data_out_reg <= 0;
            end 
        else if(crc_cnt == 18) begin 
            data_out_en_reg <= 1;
            data_out_reg <= out_swap_en ? {crc_reg[0],crc_reg[1],crc_reg[2],crc_reg[3],crc_reg[4],crc_reg[5],crc_reg[6],crc_reg[7],crc_reg[8],crc_reg[9],
                                 crc_reg[10],crc_reg[11],crc_reg[12],crc_reg[13],crc_reg[14],crc_reg[15]}:crc_reg;
            end 
        else begin 
            data_out_en_reg <= 0;
            data_out_reg <= data_out_reg;
            end 
    end     
    
    assign data_out_en = data_out_en_reg;
    assign data_out = data_out_reg ^ DATA_XOROUT;
    
endmodule
(3)CRC-32位实现
module crc_32 #(
    parameter [31:0] CRC32_PARAM = 32'h04C11DB7,
    parameter [31:0] CRC_INIT  = 32'hFFFFFFFF,
    parameter [31:0] DATA_XOROUT = 32'hFFFFFFFF
)(
    input sys_clk,
    input sys_rst,
    input in_swap_en,
    input out_swap_en,
    input data_in_en,
    input [31:0] data_in,
    output data_out_en,
    output [31:0] data_out
 );
    
    wire [31:0] swap_data;
    reg [31:0] crc_reg = CRC_INIT;
    reg [7:0] crc_cnt = 0;
    reg data_out_en_reg = 0;
    reg [31:0] data_out_reg = 0;

    assign swap_data = in_swap_en ? {data_in[24],data_in[25],data_in[26],data_in[27],data_in[28],data_in[29],data_in[30],data_in[31],  
                                 data_in[16],data_in[17],data_in[18],data_in[19],data_in[20],data_in[21],data_in[22],data_in[23],  
                                 data_in[8],data_in[9],data_in[10],data_in[11],data_in[12],data_in[13],data_in[14],data_in[15],                                 
                                 data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]}:data_in;
                              
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin 
            crc_reg <= CRC_INIT;
            crc_cnt <= 0;
            end 
        else if(data_in_en && crc_cnt == 0) begin 
            crc_reg <={swap_data[31:24]^crc_reg[31:24],crc_reg[23:0]}; 
            crc_cnt <= 1; 
            end 
        else if(crc_cnt == 9) begin 
            crc_reg <={swap_data[23:16]^crc_reg[31:24],crc_reg[23:0]}; 
            crc_cnt <= crc_cnt + 1; 
            end 
        else if(crc_cnt == 18) begin 
            crc_reg <={swap_data[15:8]^crc_reg[31:24],crc_reg[23:0]}; 
            crc_cnt <= crc_cnt + 1; 
            end 
        else if(crc_cnt == 27) begin 
            crc_reg <={swap_data[7:0]^crc_reg[31:24],crc_reg[23:0]}; 
            crc_cnt <= crc_cnt + 1; 
            end 
        else if(crc_cnt == 36) begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
        else if(crc_cnt !=0) begin// && shift_en == 0) begin 
            crc_reg <= (crc_reg[31] == 0 ? crc_reg << 1 : (crc_reg << 1 ^ CRC32_PARAM));
            crc_cnt <= crc_cnt + 1;
            end 
        else begin 
            crc_reg <= crc_reg;
            crc_cnt <= 0;
            end 
    end                        
    always @ (posedge sys_clk) begin 
        if(sys_rst) begin
            data_out_en_reg <= 0;
            data_out_reg <= 0;
            end 
        else if(crc_cnt == 36) begin 
            data_out_en_reg <= 1;
            data_out_reg <= out_swap_en ? {crc_reg[0],crc_reg[1],crc_reg[2],crc_reg[3],crc_reg[4],crc_reg[5],crc_reg[6],crc_reg[7],
                                            crc_reg[8],crc_reg[9],crc_reg[10],crc_reg[11],crc_reg[12],crc_reg[13],crc_reg[14],crc_reg[15],
                                            crc_reg[16],crc_reg[17],crc_reg[18],crc_reg[19],crc_reg[20],crc_reg[21],crc_reg[22],crc_reg[23],
                                            crc_reg[24],crc_reg[25],crc_reg[26],crc_reg[27],crc_reg[28],crc_reg[29],crc_reg[30],crc_reg[31]}:crc_reg;
            end 
        else begin 
            data_out_en_reg <= 0;
            data_out_reg <= data_out_reg;
            end 
    end     
    
    assign data_out_en = data_out_en_reg;
    assign data_out = data_out_reg ^ DATA_XOROUT;
    
endmodule

3.2 CRC并行实现

并行实现需要在网站生成计算 代码:OutputLogic.com » CRC Generator

计算流程:

a, 输入数据 翻转控制;

b,使用生成逻辑代码进行计算;

c, 对计算的CRC结果进行翻转处理;

d, 对输出的翻转数据进行异或数据处理;输出

说明:生成代码中CRC初值都为FFFF;需要根据具体设计修改;翻转控制,结果异或值等需要根据设计处理。

(1)CRC-8位实现:

实现多项式: 1+x^4+x^5+x^8

CRC初始值: 0x00

输出结果异或值:0x00

输入值使能:使能

输出值使能:使能文章来源地址https://www.toymoban.com/news/detail-423855.html

module crc_8(
    input sys_clk,
    input sys_rst,
    
    input [7:0] data_in,
    input crc_en,
    output [7:0] crc_out
);

    wire [7:0] swap_in_data;
    wire [7:0] swap_out_data;
    reg [7:0] lfsr_q,lfsr_c;    
    
    assign swap_in_data = {data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]};



    assign swap_out_data = {lfsr_q[0],lfsr_q[1],lfsr_q[2],lfsr_q[3],lfsr_q[4],lfsr_q[5],lfsr_q[6],lfsr_q[7]};

    assign crc_out = swap_out_data ^ 8'h00;
//----------------------------------------------------------------------------------------------------------------------------------------
    always @(*) begin
    
    lfsr_c[0] = lfsr_q[0] ^ lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[6] ^ swap_in_data[0] ^ swap_in_data[3] ^ swap_in_data[4] ^ swap_in_data[6];
    lfsr_c[1] = lfsr_q[1] ^ lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[7] ^ swap_in_data[1] ^ swap_in_data[4] ^ swap_in_data[5] ^ swap_in_data[7];
    lfsr_c[2] = lfsr_q[2] ^ lfsr_q[5] ^ lfsr_q[6] ^ swap_in_data[2] ^ swap_in_data[5] ^ swap_in_data[6];
    lfsr_c[3] = lfsr_q[3] ^ lfsr_q[6] ^ lfsr_q[7] ^ swap_in_data[3] ^ swap_in_data[6] ^ swap_in_data[7];
    lfsr_c[4] = lfsr_q[0] ^ lfsr_q[3] ^ lfsr_q[6] ^ lfsr_q[7] ^ swap_in_data[0] ^ swap_in_data[3] ^ swap_in_data[6] ^ swap_in_data[7];
    lfsr_c[5] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[3] ^ lfsr_q[6] ^ lfsr_q[7] ^ swap_in_data[0] ^ swap_in_data[1] ^ swap_in_data[3] ^ swap_in_data[6] ^ swap_in_data[7];
    lfsr_c[6] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[4] ^ lfsr_q[7] ^ swap_in_data[1] ^ swap_in_data[2] ^ swap_in_data[4] ^ swap_in_data[7];
    lfsr_c[7] = lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[5] ^ swap_in_data[2] ^ swap_in_data[3] ^ swap_in_data[5];
    end // always

    always @(posedge sys_clk) begin
        if(sys_rst)
            lfsr_q <= {8{1'b0}};
        else if(crc_en) 
            lfsr_q <= lfsr_c;
        else 
            lfsr_q <= lfsr_q;
    end  
  
endmodule  
(2)CRC-16位实现:

实现多项式: 1+x^2+x^15+x^16

CRC初始值: 0x0000

输出结果异或值:0xFFFF

输入值使能:使能

输出值使能:使能

module crc_16(
    input sys_clk,
    input sys_rst,
    
    input [15:0] data_in,
    input crc_en,
    output [15:0] crc_out
);

    wire [15:0] swap_in_data;
    wire [15:0] swap_out_data;
    reg [15:0] lfsr_q,lfsr_c;    
    
    assign swap_in_data = {data_in[8],data_in[9],data_in[10],data_in[11],data_in[12],data_in[13],data_in[14],data_in[15],                                 
                         data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]};



    assign swap_out_data = {lfsr_q[0],lfsr_q[1],lfsr_q[2],lfsr_q[3],lfsr_q[4],lfsr_q[5],lfsr_q[6],lfsr_q[7],
                            lfsr_q[8],lfsr_q[9],lfsr_q[10],lfsr_q[11],lfsr_q[12],lfsr_q[13],lfsr_q[14],lfsr_q[15]};

    assign crc_out = swap_out_data ^ 16'hFFFF;
//----------------------------------------------------------------------------------------------------------------------------------------
    always @(*) begin
    
    lfsr_c[0] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[6] ^ lfsr_q[7] ^ lfsr_q[8] ^ lfsr_q[9] ^ lfsr_q[10] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[15] ^ swap_in_data[0] ^ swap_in_data[1] ^ swap_in_data[2] ^ swap_in_data[3] ^ swap_in_data[4] ^ swap_in_data[5] ^ swap_in_data[6] ^ swap_in_data[7] ^ swap_in_data[8] ^ swap_in_data[9] ^ swap_in_data[10] ^ swap_in_data[11] ^ swap_in_data[12] ^ swap_in_data[13] ^ swap_in_data[15];
    lfsr_c[1] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[6] ^ lfsr_q[7] ^ lfsr_q[8] ^ lfsr_q[9] ^ lfsr_q[10] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[13] ^ lfsr_q[14] ^ swap_in_data[1] ^ swap_in_data[2] ^ swap_in_data[3] ^ swap_in_data[4] ^ swap_in_data[5] ^ swap_in_data[6] ^ swap_in_data[7] ^ swap_in_data[8] ^ swap_in_data[9] ^ swap_in_data[10] ^ swap_in_data[11] ^ swap_in_data[12] ^ swap_in_data[13] ^ swap_in_data[14];
    lfsr_c[2] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[14] ^ swap_in_data[0] ^ swap_in_data[1] ^ swap_in_data[14];
    lfsr_c[3] = lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[15] ^ swap_in_data[1] ^ swap_in_data[2] ^ swap_in_data[15];
    lfsr_c[4] = lfsr_q[2] ^ lfsr_q[3] ^ swap_in_data[2] ^ swap_in_data[3];
    lfsr_c[5] = lfsr_q[3] ^ lfsr_q[4] ^ swap_in_data[3] ^ swap_in_data[4];
    lfsr_c[6] = lfsr_q[4] ^ lfsr_q[5] ^ swap_in_data[4] ^ swap_in_data[5];
    lfsr_c[7] = lfsr_q[5] ^ lfsr_q[6] ^ swap_in_data[5] ^ swap_in_data[6];
    lfsr_c[8] = lfsr_q[6] ^ lfsr_q[7] ^ swap_in_data[6] ^ swap_in_data[7];
    lfsr_c[9] = lfsr_q[7] ^ lfsr_q[8] ^ swap_in_data[7] ^ swap_in_data[8];
    lfsr_c[10] = lfsr_q[8] ^ lfsr_q[9] ^ swap_in_data[8] ^ swap_in_data[9];
    lfsr_c[11] = lfsr_q[9] ^ lfsr_q[10] ^ swap_in_data[9] ^ swap_in_data[10];
    lfsr_c[12] = lfsr_q[10] ^ lfsr_q[11] ^ swap_in_data[10] ^ swap_in_data[11];
    lfsr_c[13] = lfsr_q[11] ^ lfsr_q[12] ^ swap_in_data[11] ^ swap_in_data[12];
    lfsr_c[14] = lfsr_q[12] ^ lfsr_q[13] ^ swap_in_data[12] ^ swap_in_data[13];
    lfsr_c[15] = lfsr_q[0] ^ lfsr_q[1] ^ lfsr_q[2] ^ lfsr_q[3] ^ lfsr_q[4] ^ lfsr_q[5] ^ lfsr_q[6] ^ lfsr_q[7] ^ lfsr_q[8] ^ lfsr_q[9] ^ lfsr_q[10] ^ lfsr_q[11] ^ lfsr_q[12] ^ lfsr_q[14] ^ lfsr_q[15] ^ swap_in_data[0] ^ swap_in_data[1] ^ swap_in_data[2] ^ swap_in_data[3] ^ swap_in_data[4] ^ swap_in_data[5] ^ swap_in_data[6] ^ swap_in_data[7] ^ swap_in_data[8] ^ swap_in_data[9] ^ swap_in_data[10] ^ swap_in_data[11] ^ swap_in_data[12] ^ swap_in_data[14] ^ swap_in_data[15];

    end // always

    always @(posedge sys_clk) begin
        if(sys_rst)
            lfsr_q <= {16{1'b0}};
        else if(crc_en) 
            lfsr_q <= lfsr_c;
        else 
            lfsr_q <= lfsr_q;
    end  
  
endmodule  
(3)CRC-32位实现:

实现多项式: 1+x^1+x^2+x^4+x^5+x^7+x^8+x^10+x^11+x^12+x^16+x^22+x^23+x^26+x^32

CRC初始值: 0xFFFFFFFF

输出结果异或值:0xFFFFFFFF

输入值使能:使能

输出值使能:使能


module crc_32(
    input sys_clk,
    input sys_rst,
    
    input [31:0] data_in,
    input crc_en,
    output [31:0] crc_out
);
    wire [31:0] swap_in_data;
    wire [31:0] swap_out_data;
    reg [31:0] lfsr_q,lfsr_c;    
    
    assign swap_in_data = {data_in[24],data_in[25],data_in[26],data_in[27],data_in[28],data_in[29],data_in[30],data_in[31],  
                             data_in[16],data_in[17],data_in[18],data_in[19],data_in[20],data_in[21],data_in[22],data_in[23],  
                             data_in[8],data_in[9],data_in[10],data_in[11],data_in[12],data_in[13],data_in[14],data_in[15],                                 
                             data_in[0],data_in[1],data_in[2],data_in[3],data_in[4],data_in[5],data_in[6],data_in[7]};



    assign swap_out_data = {lfsr_q[0],lfsr_q[1],lfsr_q[2],lfsr_q[3],lfsr_q[4],lfsr_q[5],lfsr_q[6],lfsr_q[7],
                                       lfsr_q[8],lfsr_q[9],lfsr_q[10],lfsr_q[11],lfsr_q[12],lfsr_q[13],lfsr_q[14],lfsr_q[15],
                                       lfsr_q[16],lfsr_q[17],lfsr_q[18],lfsr_q[19],lfsr_q[20],lfsr_q[21],lfsr_q[22],lfsr_q[23],
                                       lfsr_q[24],lfsr_q[25],lfsr_q[26],lfsr_q[27],lfsr_q[28],lfsr_q[29],lfsr_q[30],lfsr_q[31]};

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

    always @(posedge sys_clk) begin
        if(sys_rst)
            lfsr_q <= {32{1'b1}};
        else if(crc_en) 
            lfsr_q <= lfsr_c;
        else 
            lfsr_q <= lfsr_q;
    end  
  
endmodule  

到了这里,关于十六、基于FPGA的CRC校验设计实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【STM32】CRC(循环冗余校验)

    (1)CRC(Cyclic Redundancy Check),循环冗余校验 (2) 什么是校验,为什么需要校验:数据传输,数据存储过程中需要使用到的 (3)什么是 冗余:表示比实际上要传输的数据还要多 (4)校验实现的关键: 冗余少、运算少、识错纠错能力强 (有些算法只能识别错误但是无法纠错) (1)(

    2024年02月03日
    浏览(49)
  • JAVA获取CRC(即循环冗余校验)

    前言:网上查了很多,CRC计算时,除数长度太长无法计算,所以写此文章。希望大家喜欢!     CRC(Cyclic Redundancy Check),即循环冗余校核,是一种根据网络数据包或电脑文件等数据产生简短固定位数 校核码 的快速算法。      CRC校验本质上是选取一个合适的 除数 ,要进行校

    2024年02月06日
    浏览(43)
  • 从原理到代码理解CRC循环冗余校验

    概述:本文详细介绍了CRC循环冗余计算的数学原理,算法中使用的参数说明,并以Modbus协议中的CRC-16算法为例,进行手算验证,同时提供LabVIEW和C语言的直接计算CRC-16 值的代码以及C的查表计算CRC-16代码和代码原理的说明。 初次接触CRC校验是因为项目需要上位机软件来记录P

    2024年02月04日
    浏览(43)
  • 【基础知识】CRC(循环冗余校验)直接计算和查表法

    校验是什么,个人理解就是经过一个算法,使用大量数据(几MB的数据)生成较小长度的一串信息(如16Bit),并切要做到 原数据不同时,生成的信息大概率不同(不是加密算法不考虑刻意造数据的情况) 原数据中任意一个或几个数据出现错误时,生成的信息不同(所有的原信

    2024年02月05日
    浏览(60)
  • 计算机网络:数据链路层之差错控制、奇偶校验码、CRC循环冗余码、海明码

    带你度过期末难关 文章目录 一、差错控制 1、冗余编码 2、编码VS编码 二、检错编码 1、奇偶校验码 2、CRC循环冗余码 三、纠错编码————海明码 海明距离 1、确定校验码位数r 2、确定校验码和数据的位置 3、求出校验码的值 4、检错并纠错 纠错的方法一: 纠错方法二: 总

    2024年02月04日
    浏览(54)
  • JS十六进制,CRC冗余,小程序发送蓝牙数据,十六进制GBK编码转换等

    小程序问题:https://kf.qq.com/faq/170705YVZFZZ170705eyI7Rr.html 调用: 注意:这里的true和false代表是否大端小端转换 调用: 调用: 调用: 调用: 调用: 此代码写到小程序utils目录下的utuils.js文件中 调用:页面最上边先引入,然后再使用 调用: 这里发送buffer1给小程序公用api就可 调

    2024年02月16日
    浏览(72)
  • CRC校验原理与FPGA实现(含推导过程)

      CRC校验全称为循环冗余校验(Cyclic Redundancy Check),常用于数据传输中的错误检测。   在学习CRC校验前,需要了解CRC校验中的几个基本概念: NAME:参数模型名称,比如CRC-8、CRC-16、CRC-32等 WIDTH:CRC校验位宽度 POLY:多项式的简写,用十六进制表示。例如:CRC-8的多项式

    2024年02月03日
    浏览(90)
  • 题解校验码—CRC循环校验码与海明校验码

    一个编码系统的码距是 任意两个码字 的最小距离。 例如个编码系统采用三位长度的二进制编码,若该系统有四种编码分别为:000,011,100,111,此编码系统中000与111的码距为3;011与000的码距为2;011与111的码距为1,则该编码系统的码距为1。 码距计算方法:两个编码按位异

    2024年02月04日
    浏览(44)
  • 解决灵科路由循环冗余校验错误排除操作指南

    本文为大家介绍的是由于路由器循环冗余校验错误,所造成POS故障的解决办法,循环冗余校验,其特点是:检错能力极强,开销小,易于用编码器及检测电路实现,从其检错能力来看,它所不能发现的错误的几率非常低。 一、组网环境 在灵科路由器的组网环境中,在个点使用

    2024年02月05日
    浏览(44)
  • 孩子都能学会的FPGA:第十课——UART通信增加CRC校验

    (原创声明:该文是 作者的原创 ,面向对象是 FPGA入门者 ,后续会有进阶的高级教程。宗旨是 让每个想做FPGA的人轻松入门 , 作者不光让大家知其然,还要让大家知其所以然 !每个工程作者都搭建了全自动化的仿真环境,只需要双击 top_tb.bat 文件就可以完成整个的仿真(前

    2024年02月05日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包