精华内容
下载资源
问答
  • 线性反馈移位寄存器 (LFSR) 是一种生成序列(包括伪随机数序列)的简单方法。 提供的 LFSR 代码非常不受限制,允许任何反馈多项式、初始状态或抽取因子。 该代码是为 32 位 LFSR 编写的,但稍作改动就可以使用 8-64 ...
  • 1)利用C\C++语言实现给定的LFSR; 2)通过不同初始状态生成相应的序列,并观察它们的周期有什么特点; 3)利用生成的序列对文本进行加/解密(按对应位作模2加运算)。 步骤: ...(1)生成序列:使用#include库构造...
  • 提出并用电路实现了一种改进的线性反馈移位寄存器(LFSR)算法。改进的算法克服了传统线性反馈移位寄存器产生随机数的速度受字长制约的限制,其电路结构能够快速地产生任意字长的伪随机序列。用现场可编程门阵列...
  • 线性反馈移位寄存器

    2013-12-25 03:42:40
    关于线性反馈移位寄存器的代码,模拟LFSR运行
  • 此文档内含有用java实现的周期为8001的线性反馈移位寄存器
  • 流密码 该存储库包含我最流行的流密码的实现-线性反馈移位寄存器( )。
  • Dn 型非线性反馈移位寄存器,张跃辉,, 本文研究了一类Dynkin型非线性反馈移位寄存器,给出了n长码是$D_{n}$型反馈函数的周期码的充分必要条件,并得出了所有周期码 及其周期
  • matlab自相关代码LFSR-线性反馈移位寄存器 链接: | | | | _安装: 目录 新的更新 用pylfsr绘制LFSR 更新: 修复了错误(1)缺少初始位(2)异常的问题 增加了LFSR的测试属性 (1)财产余额 (2)游程属性 (3)自...
  • 一些非线性反馈移位寄存器的周期结构
  • 线性反馈移位寄存器
  • 面向可重构并行化处理的线性反馈移位寄存器统一架构研究
  • 线性反馈移位寄存器反馈分为两种,一种是IE型的LFSR,即异或门内接的线性反馈移位寄存器: 另一种是异或门外接的线性反馈移位寄存器,简称EE型LFSR: gi表示接不接入反馈,只能为0或1,为1即为

    一、什么是LFSR?

    线性反馈移位寄存器(linear feedback shift register, LFSR)是指,给定前一状态的输出,将该输出的线性函数再用作输入的移位寄存器。异或运算是最常见的单比特线性函数:对寄存器的某些位进行异或操作后作为输入,再对寄存器中的各比特进行整体移位(百度百科定义)。

    线性反馈移位寄存器反馈分为两种,一种是IE型的LFSR,即异或门内接的线性反馈移位寄存器:

    在这里插入图片描述
    另一种是异或门外接的线性反馈移位寄存器,简称EE型LFSR
    在这里插入图片描述
    gi表示接不接入反馈,只能为0或1,为1即为接入,为0不接入。

    关于线性反馈移位寄存器(LFSR)数学原理更加详细的介绍,可以参考下面这篇文章。

    本文主要是介绍如果使用verilog来实现LFSR电路的编写。

    需要注意的是,LFSR是伪随机的,这意味着它只是接近随机,并不是完全随机的。这是因为其实从LFSR的任何状态,你都可以预测下一个状态。 有一些重要的移位寄存器属性需要注意:

    • LFSR是伪随机的,从LFSR的任何状态,都可以预测下一个状态。

    • 影响下一个状态的比特位叫做抽头。当抽头使用XOR门时,全0状态不会出现,这是因为0与0异或将始终产生0,此时LFSR将停止运行。当抽头使用XNOR门时,全1状态不会出现,这是因为1与1同或(异或非)将始终产生1,此时LFSR将停止运行。

    • 任何LFSR的最大可能迭代次数 = 2^N-1,N为级数,也就是寄存器bit位的个数。

    那么怎样的LFSR才能遍历2^N-1个状态,产生最大的迭代次数呢?也就是到底寄存器的哪些位去组合然后反馈到输入端,才能使该LFSR的所有2^N-1个状态都出现呢?这里官方给了一个表,我们可以根据这个表来确定LFSR的结构:
    在这里插入图片描述
    需要注意的是LFSR的每一位的索引是从1开始,然后到N,一共 2^N-1个状态(因为使用异或反馈时要除去全0状态,使用异或非反馈时要除去全1状态)。表中使用的是异或非XNOR。

    二、代码设计

    代码设计部分没有什么难点,主要是会移位寄存器的写法就可以。然后初始值seed_data在使用XNOR时,不要给全1就可以。

    `timescale 1ns / 1ps
    module lfsr #(parameter Bits_Num = 5)(
       input clk,
       input rst_n,
     
       // data valid
       input seed_valid,
    
       // Optional Seed Value
       input [Bits_Num-1:0] seed_data,
     
       output [Bits_Num-1:0] o_LFSR_data
    
        );
    
      reg [Bits_Num:1] LFSR_reg = 0;//保存移位寄存器的状态
      reg              XNOR_reg;
     
     
        always @(posedge clk)
        begin
          if (rst_n != 1'b0)
          begin
              if (seed_valid == 1'b1)
                LFSR_reg <= seed_data;
              else
                LFSR_reg <= {LFSR_reg[Bits_Num-1:1],XNOR_reg}; //left right
          end
        end
    
    
        always @(*)
        begin
          case (Bits_Num)
            3: begin
              XNOR_reg = LFSR_reg[3] ^~ LFSR_reg[2];
            end
            4: begin
              XNOR_reg = LFSR_reg[4] ^~ LFSR_reg[3];
            end
            5: begin
              XNOR_reg = LFSR_reg[5] ^~ LFSR_reg[3];
            end
            6: begin
              XNOR_reg = LFSR_reg[6] ^~ LFSR_reg[5];
            end
            7: begin
              XNOR_reg = LFSR_reg[7] ^~ LFSR_reg[6];
            end
            8: begin
              XNOR_reg = LFSR_reg[8] ^~ LFSR_reg[6] ^~ LFSR_reg[5] ^~ LFSR_reg[4];
            end
            9: begin
              XNOR_reg = LFSR_reg[9] ^~ LFSR_reg[5];
            end
            10: begin
              XNOR_reg = LFSR_reg[10] ^~ LFSR_reg[7];
            end
            11: begin
              XNOR_reg = LFSR_reg[11] ^~ LFSR_reg[9];
            end
            12: begin
              XNOR_reg = LFSR_reg[12] ^~ LFSR_reg[6] ^~ LFSR_reg[4] ^~ LFSR_reg[1];
            end
            13: begin
              XNOR_reg = LFSR_reg[13] ^~ LFSR_reg[4] ^~ LFSR_reg[3] ^~ LFSR_reg[1];
            end
            14: begin
              XNOR_reg = LFSR_reg[14] ^~ LFSR_reg[5] ^~ LFSR_reg[3] ^~ LFSR_reg[1];
            end
            15: begin
              XNOR_reg = LFSR_reg[15] ^~ LFSR_reg[14];
            end
            16: begin
              XNOR_reg = LFSR_reg[16] ^~ LFSR_reg[15] ^~ LFSR_reg[13] ^~ LFSR_reg[4];
              end
            17: begin
              XNOR_reg = LFSR_reg[17] ^~ LFSR_reg[14];
            end
            18: begin
              XNOR_reg = LFSR_reg[18] ^~ LFSR_reg[11];
            end
            19: begin
              XNOR_reg = LFSR_reg[19] ^~ LFSR_reg[6] ^~ LFSR_reg[2] ^~ LFSR_reg[1];
            end
            20: begin
              XNOR_reg = LFSR_reg[20] ^~ LFSR_reg[17];
            end
            21: begin
              XNOR_reg = LFSR_reg[21] ^~ LFSR_reg[19];
            end
            22: begin
              XNOR_reg = LFSR_reg[22] ^~ LFSR_reg[21];
            end
            23: begin
              XNOR_reg = LFSR_reg[23] ^~ LFSR_reg[18];
            end
            24: begin
              XNOR_reg = LFSR_reg[24] ^~ LFSR_reg[23] ^~ LFSR_reg[22] ^~ LFSR_reg[17];
            end
            25: begin
              XNOR_reg = LFSR_reg[25] ^~ LFSR_reg[22];
            end
            26: begin
              XNOR_reg = LFSR_reg[26] ^~ LFSR_reg[6] ^~ LFSR_reg[2] ^~ LFSR_reg[1];
            end
            27: begin
              XNOR_reg = LFSR_reg[27] ^~ LFSR_reg[5] ^~ LFSR_reg[2] ^~ LFSR_reg[1];
            end
            28: begin
              XNOR_reg = LFSR_reg[28] ^~ LFSR_reg[25];
            end
            29: begin
              XNOR_reg = LFSR_reg[29] ^~ LFSR_reg[27];
            end
            30: begin
              XNOR_reg = LFSR_reg[30] ^~ LFSR_reg[6] ^~ LFSR_reg[4] ^~ LFSR_reg[1];
            end
            31: begin
              XNOR_reg = LFSR_reg[31] ^~ LFSR_reg[28];
            end
            32: begin
              XNOR_reg = LFSR_reg[32] ^~ LFSR_reg[22] ^~ LFSR_reg[2] ^~ LFSR_reg[1];
            end
     
          endcase // case (Bits_Num)
        end // always @ (*)
    
        assign o_LFSR_data = LFSR_reg;
    
    
    endmodule
    
    仿真程序:
    `timescale 1ns / 1ps
    module lfsr_tb ();
     
      parameter Bits_Num = 5;
      //input
      reg clk = 1'b0;
      reg rst_n = 1'b0;
      reg seed_valid = 1'b0;
      reg [Bits_Num-1:0]seed_data = 1'b0;
      //output
      wire [Bits_Num-1:0] o_LFSR_data;
       
      lfsr #(.Bits_Num(Bits_Num)) u_lfsr
             (.clk(clk),
              .rst_n(rst_n),
              .seed_valid(seed_valid),
              .seed_data(seed_data),
              .o_LFSR_data(o_LFSR_data)
              );
      
      always @(*)
        #5 clk <= ~clk; 
       
    initial
    begin
        #20 rst_n  =  1;
    end
    
    initial
    begin
        #15 seed_valid  =  1;
            seed_data   =  5;
        #10 seed_valid  =  0;
    end
    initial
    begin
        #100 $finish;
    end
    endmodule 
    

    在这里插入图片描述
    在25ns时采样到seed_data = 5LFSR_reg初始值被置为了00101,然后通过:

    LFSR_reg <= {LFSR_reg[Bits_Num-1:1],XNOR_reg}; //left right
    
    XNOR_reg = LFSR_reg[5] ^~ LFSR_reg[3];
    

    计算得到00001也即1,然后后面依次按照算法计算即可。

    展开全文
  • 线性反馈移位寄存器LFSR和循环冗余码CRC0 前言1 数学基础1.1 逻辑异或1.2 模2乘法 和 模2除法2 线性反馈移位寄存器LFSR2.1 抽头和特征多项式3 循环冗余码CRC 0 前言 线性反馈移位寄存器(Linear Feedback Shift ...

    0 前言

    线性反馈移位寄存器(Linear Feedback Shift Register,LFSR)和循环冗余码(Cyclic Redundancy Check,CRC)是微控制器中常用的底层原理。

    LFSR用于生成伪随机数,后者用于生成检错码。他们的数学原理都是一样的。

    1 数学基础

    1.1 逻辑异或

    异或运算使用符号或者nor表示,真值表如下
    F = A ⊕ B

    ABF
    000
    011
    101
    110

    异或运算可以有3种理解方式:

    1 相同得1,不同得0

    2 二进制加法,只留模2的余数,抛弃进位(模2加法)

    3 二进制减法,大数减小数,不借位(模2减法)

    1.2 模2乘法 和 模2除法

    两个二进制数的模2乘法是指在乘法竖式运算中需要做加法的地方都使用异或运算

    模2乘法1010 * 101=100010,下图红框中,1⊕0⊕1=0,没有进位

    在这里插入图片描述
    两个二进制数的模2除法是指在除法竖式运算中需要做减法的地方都使用异或运算

    模2除法10000 / 101=1011,下图红框中,0⊕1=1,没有借位
    在这里插入图片描述

    2 线性反馈移位寄存器LFSR

    以斐波那契(外部LFSR)为例,有n个二进制寄存器R0-Rn-1,每个寄存器值为01
    在这里插入图片描述
    k阶段,寄存器存在初值,(Rn-1, … R1, R0),称为seed
    k+1阶段,寄存器的值变为:

    k+1阶段
    Rn-1 = Rn-2
    Rn-2 = Rn-3
    R0 = f(R1, R2, …, Rn-1) = (Rn-1*gn)⊕(Rn-2*gn-1)⊕…⊕(R0*g1)*g0

    也就是说寄存器存储的结果 (Rn-1, … R1, R0) 每个时钟周期改变一次,其中R1-Rn-1是位移产生,R0是线性反馈函数 f(Rn-1, … R1, R0) 产生,所以称为线性反馈移位寄存器。

    线性反馈移位寄存器总是假定g0,gn1,否则 (Rn-1, … R1, R0) 将在n个周期后恒定为0

    2.1 抽头和特征多项式

    f(Rn-1, … R1, R0) = (Rn-1*gn)⊕(Rn-2*gn-1)⊕…⊕(R0*g1)*g0 可以用多项式表示为:

    G(x)=gnxn+gn-1xn-1+…+g1x+g0

    G(x)称为LFSR的特征多项式

    影响线性反馈寄存器下一个状态的 gi = 01叫做抽头,抽头的设定会决定线性反馈寄存器存储的结果 (Rn-1, … R1, R0) 的变化规律。

    通常N位的线性反馈寄存器最多有 2N 个不同的状态。但是如果出现初值为N个0的情况,线性反馈寄存器陷入死循环,要排除掉。所以N位线性反馈寄存器能产生最长的不重复序列为 2N-1。

    抽头的位置会影响LSFR的最大输出状态的个数
    例如:3位的抽头为(g3, g2, g1, g0) = (1, 1, 0, 1)会产生7个状态(多项式对应为:G(x)=x3+x2+1)
    若抽头为(g3, g2, g1, g0) = (1, 0, 1, 1),会产生2个状态(多项式对应为:x3+x+1)。

    使最大输出序列长度为2N-1的不可约多项式称为LFSR的本原多项式,本原多项式产生的寄存器序列为M序列

    当N位下,本原多项式不是唯一的。下表为不同的位下的本原多项式:
    在这里插入图片描述
    在这里插入图片描述

    2.2 3阶线性反馈移位寄存器实例

    在这里插入图片描述
    上图为3阶线性反馈移位寄存器
    抽头为(g3, g2, g1, g0) = (1, 1, 0, 1)
    多项式对应为:G(x)=x3+x2+1
    线性反馈函数R0 = f(R2, R1, R0) = R1⊕R2
    初始值为SEED = (R2, R1, R0) = (1, 0, 1)

    3阶线性反馈移位寄存器周期为7:

    k周期(R2, R1, R0)
    0(1, 0, 1)
    1(0, 1, 1)
    2(1, 1, 1)
    3(1, 1, 0)
    4(1, 0, 0)
    5(0, 0, 1)
    6(0, 1, 0)
    7(1, 0, 1)

    通过设定seed和抽头,LFSR最多可产生2N-1个序列,这些序列之间看似是随机产生的,之所以称之为伪随机,是因为这些数是通过具体的关系式产生,最终会实现循环。

    3 循环冗余码CRC

    现实的通信链路都不会是理想的。这就是说,比特在传输的过程中可能会产生差错:1可能会变成0,0可能会变成1,这就叫做比特差错。
    因此,为了保证数据传输的可靠性,在计算机网络传输数据时,必须采用各种差错检测措施。
    目前在数据链路层广泛使用了循环冗余检测CRC的检测技术

    3.1 CRC的原理

    CRC运算实际上就是在数据长为k的后面添加供差错检测用的n位冗余码,然后构成帧k+n位发送出去。

    在这里插入图片描述
    选择一个生成多项式,作为对接收的帧进行除法运算时的除数,生成多项式可以写为二进制形式;生成多项式的要求:
    ①最高位和最低位必须为1;
    ②当CRC码的任何一位发生错误时,新帧除生成多项式后余数不为0;
    ③不同位发生错误时,余数应该是不同的;

    计算n位冗余码
    现假定待传输的数据M = 101001(k = 6),除数p = 1101 (n = 3,p比n多一位)
    这n位冗余码可以用下面的方法得出。
    (1)用二进制的模2运算进行(2^n)乘M的运算,相当于在M后面添加n个0。
    即M后面添加3个0
    (2)现在得到M = 101001000(k+n = 9)位的数除以除数p(n = 3)位,
    得到余数R =001(n位),R就是冗余码FCS

    现在加上CRC后发送的帧是101001001

    在接收端把接收到的数据M = 101001001以帧为单位进行CRC检验:把收到的每一个帧都除以相同的除数p(模2运算),然后检查得到的余数R。
    如果在传输过程中没有差错,那么经过检验后得到余数R肯定是0。
    (读者可以自己检验下,被除数现在是M = 101001001,除数P= 1101,看余数是否为0)
    总之,在接收端对接收到的每一个帧经过CRC检验后,有两种情况:
    (1)余数R = 0,则判断这个帧没有问题,就接受
    (2)余数R != 0,则判断这个帧有差错,就丢弃。

    3.2 CRC的实例

    假设CRC生成多项式G(X)=X5+X4+X+1,要发送的二进制数据帧为100101110,求CRC校验码:

    ①把生成多项式转换为二进制数:110011;

    ②由生成多项式的位数为6可知,CRC校验码的位数为5,所以在数据帧后加5个0,变为10010111000000,将这个数使用模2除法除以生成多项式110011,得到余数即CRC校验码11010;
    在这里插入图片描述
    ③用得到的CRC校验码替换掉数据帧中的5个0,形成新的帧10010111011010,将这个新帧发送给接收端;

    ④接收端收到新帧后,用新帧除以上面的多项式110011(模2除法),如果余数为0,该数据帧在传输过程中没有出错,否则出错;(经验证余数为0)

    展开全文
  • 线性反馈移位寄存器LFSR,是移位寄存器的一种,通常用于在数字电路中产生伪随机数。寄存器中的初始值叫做种子,种子应该是非零的。LFSR的下一时刻输入为是由整个移位寄存器值的某些位做异或运算的结果。选取哪些位置...

    线性反馈移位寄存器LFSR,是移位寄存器的一种,通常用于在数字电路中产生伪随机数。寄存器中的初始值叫做种子,种子应该是非零的。LFSR的下一时刻输入为是由整个移位寄存器值的某些位做异或运算的结果选取哪些位置 用于移位,是需要进行预先设计好的,目的是要产生一个伪随机并且尽可能长周期的数字序列

    n位LFSR,最多产生2^(n-1)种序列(全零或全一被排除,因为全零异或nor结果为0,不会产生新序列,全1同或xnor也是)。

    影响下一个状态的比特位叫做抽头。移位寄存器链的多个抽头用作XOR或XNOR门的输入。 然后,此门的输出用作对移位寄存器链开始的反馈,因此用作LFSR中的反馈。

    注意:当抽头使用XOR门时,全0的模式不会出现。 当抽头使用XNOR门时,全1的模式将不会出现。 此两种情况LFSR将停止运行。LFSR是伪随机的。输出模式是确定性,可以通过了解XOR门的位置以及当前模式来确定下一个状态。

    怎样选取抽头可以产生最大长度的随机序列,可以参考下表;

    LFSR的特征方程根据抽头位置来定:

     这里可以表示为f(x)=1+c1x+c2x^(2)+c3x^(3)+...+cnx^(n)

    比如,如果n=3,f(x)=1+c1x+c2x^(2)+c3x^(3),其中c1和c3为1,那么f(x)=1+x+x^3,抽头对应为a3,a1。

    如果初始序列是101,
    则输出为:101001110100111010011……

    `timescale 1ns/1ps
    module top_module ();
        reg clk=0;
        always #5 clk = ~clk;  // Create clock with period=10
        initial `probe_start;   // Start the timing diagram
    
        `probe(clk);        // Probe signal "clk"
    
        // A testbench
        reg set_seed;
        reg [2:0] seed_data;
        reg enable;
        parameter bits_num=3;
        initial begin
            set_seed=1;
            enable=1;
            seed_data=3'b101;
            #10  set_seed=0;
            #60 $finish;            // Quit the simulation
        end
        LFSR #(.bits_num(bits_num)) inst1( .clk(clk),.enable(enable),.set_seed(set_seed),.seed_data(seed_data));   // Sub-modules work too.
    endmodule
    module  LFSR #(parameter bits_num=3)(
       input clk,
       input enable, 
       input set_seed,
       input [bits_num-1:0] seed_data,
       output [bits_num-1:0] lfsr_data,
       output lfsr_done//cycle done
        );
        `probe(clk);
        `probe(enable);
        `probe(set_seed);
        `probe(seed_data);
        `probe(lfsr_data);
        `probe(r_lfsr);
       reg [bits_num:1] r_lfsr;
       reg              r_xnor;
     
        always @(posedge clk)
        begin
          if (enable == 1'b1)
          begin
              if (set_seed == 1'b1)
              r_lfsr <= seed_data;
              else begin
                  $display("1.r_lfsr=%b,time=%g",r_lfsr,$time);
              r_lfsr <= {r_lfsr[bits_num-1:1],r_xnor}; 
                  $display("2.r_lfsr=%b,r_xnor=%b,time=%g",r_lfsr,r_xnor,$time);
              end
          end
        end
        
        always @(*)//一开始就要有变化,所以不设置为posedge clk。
        begin
            case (bits_num)//3-32
            3: begin
              r_xnor = r_lfsr[3] ^~ r_lfsr[2];
            end
            4: begin
              r_xnor = r_lfsr[4] ^~ r_lfsr[3];
            end
            5: begin
              r_xnor = r_lfsr[5] ^~ r_lfsr[3];
            end
            6: begin
              r_xnor = r_lfsr[6] ^~ r_lfsr[5];
            end
            7: begin
              r_xnor = r_lfsr[7] ^~ r_lfsr[6];
            end
            8: begin
              r_xnor = r_lfsr[8] ^~ r_lfsr[6] ^~ r_lfsr[5] ^~ r_lfsr[4];
            end
            9: begin
              r_xnor = r_lfsr[9] ^~ r_lfsr[5];
            end
            10: begin
              r_xnor = r_lfsr[10] ^~ r_lfsr[7];
            end
            11: begin
              r_xnor = r_lfsr[11] ^~ r_lfsr[9];
            end
            12: begin
              r_xnor = r_lfsr[12] ^~ r_lfsr[6] ^~ r_lfsr[4] ^~ r_lfsr[1];
            end
            13: begin
              r_xnor = r_lfsr[13] ^~ r_lfsr[4] ^~ r_lfsr[3] ^~ r_lfsr[1];
            end
            14: begin
              r_xnor = r_lfsr[14] ^~ r_lfsr[5] ^~ r_lfsr[3] ^~ r_lfsr[1];
            end
            15: begin
              r_xnor = r_lfsr[15] ^~ r_lfsr[14];
            end
            16: begin
              r_xnor = r_lfsr[16] ^~ r_lfsr[15] ^~ r_lfsr[13] ^~ r_lfsr[4];
              end
            17: begin
              r_xnor = r_lfsr[17] ^~ r_lfsr[14];
            end
            18: begin
              r_xnor = r_lfsr[18] ^~ r_lfsr[11];
            end
            19: begin
              r_xnor = r_lfsr[19] ^~ r_lfsr[6] ^~ r_lfsr[2] ^~ r_lfsr[1];
            end
            20: begin
              r_xnor = r_lfsr[20] ^~ r_lfsr[17];
            end
            21: begin
              r_xnor = r_lfsr[21] ^~ r_lfsr[19];
            end
            22: begin
              r_xnor = r_lfsr[22] ^~ r_lfsr[21];
            end
            23: begin
              r_xnor = r_lfsr[23] ^~ r_lfsr[18];
            end
            24: begin
              r_xnor = r_lfsr[24] ^~ r_lfsr[23] ^~ r_lfsr[22] ^~ r_lfsr[17];
            end
            25: begin
              r_xnor = r_lfsr[25] ^~ r_lfsr[22];
            end
            26: begin
              r_xnor = r_lfsr[26] ^~ r_lfsr[6] ^~ r_lfsr[2] ^~ r_lfsr[1];
            end
            27: begin
              r_xnor = r_lfsr[27] ^~ r_lfsr[5] ^~ r_lfsr[2] ^~ r_lfsr[1];
            end
            28: begin
              r_xnor = r_lfsr[28] ^~ r_lfsr[25];
            end
            29: begin
              r_xnor = r_lfsr[29] ^~ r_lfsr[27];
            end
            30: begin
              r_xnor = r_lfsr[30] ^~ r_lfsr[6] ^~ r_lfsr[4] ^~ r_lfsr[1];
            end
            31: begin
              r_xnor = r_lfsr[31] ^~ r_lfsr[28];
            end
            32: begin
              r_xnor = r_lfsr[32] ^~ r_lfsr[22] ^~ r_lfsr[2] ^~ r_lfsr[1];
            end 
          endcase 
        end 
        
        assign lfsr_data = r_lfsr[bits_num:1];
        assign lfsr_done = (r_lfsr[bits_num:1] == seed_data) ? 1'b1 : 1'b0;
    endmodule

    结果:

    LFSR分为两种:一种是IE型的LFSR,即异或门内接的线性反馈移位寄存器,如下图第一张。另一种是异或门外接的线性反馈移位寄存器,简称EE型LFSR,如第二张。这两种类型在代码表现上是不一样的。第一种LFSR的任何一位,如果g=1,其下一时刻值就是输出位以及其前一位的异或。

    第二种LFSR的任何一位,如果g=1,其下一时刻值就是其前一位的值,但是输入位的值,就需要其参与异或得到。

     

    展开全文
  • Verilog-LFSR线性反馈移位寄存器1 LFSR 是什么2 几道题目2.1 题目1:5-bit LFSR2.2 题目2:3-bit LFSR2.3 题目3:32-bit LFSR 1 LFSR 是什么 在HDLBits网站做到了几道关于LFSR,Liner Feedback Shift Register线性...

    1 LFSR 是什么

    在HDLBits网站做到了几道关于LFSR,Liner Feedback Shift Register线性反馈移位寄存器的题目,总结如下。

    所谓LFSR,就是指移位寄存器的某些位在移位之前进行了异或操作。普通的移位寄存器中下一级别D触发器的输入是上一级别D触发器的输出,而LFSR下一级别D触发器的输入不是上一级别D触发器饿输出,而是有可能和其他级(一般是最后一级,也就是第0位)进行异或操作之后作为下一级别触发器的输入。下面这个图可以帮助理解。
    在这里插入图片描述

    线性反馈移位寄存器是通常带有几个XOR门的移位寄存器,用于产生移位寄存器的下一个状态。 Galois LFSR是一种特殊的移位寄存器,其中将带有“抽头”的位位置与输出位进行异或运算以产生其下一个值。 如果仔细选择抽头位置,则可以将LFSR设为“最大长度”。 n位的最大长度LFSR在重复之前循环经过2n

    展开全文
  • 线性反馈移位寄存器(LFSR):通常由移位寄存器和异或门逻辑组成。其主要应用在:伪随机数,伪噪声序列,计数器,BIST,数据的加密和CRC校验等。 线性反馈移位寄存器(LFSR)主要包括两大类 伽罗瓦(内部LFSR),又称one-...
  • 我们先来了解一下什么是线性反馈移位寄存器(LFSR) ...用反馈函数表示成y=a0x0+a1x+a2x2…反馈函数为线性的叫线性移位反馈序列,否则叫非线性反馈移位序列。 简单来说LFSR就是给定前一状态的输出,将
  • 线性反馈移位寄存器实现产生伪随机数M序列 -----在CN03平台上,主要体现为Random功能的实现。 什么是线性反馈移位寄存器? 数学解释这里就不作介绍了,这里我们主要理解两个词语就行,一个是线性,它是指量与量...
  • 线性反馈移位寄存器,介绍了移位寄存器在除法器,编码器,解码器中的使用!
  • LFSR线性反馈移位寄存器,简单易懂,用于矩阵课的LFSR学习
  • 简述线性反馈移位寄存器

    千次阅读 2020-04-12 17:39:20
    反馈移位寄存器 移位寄存器是流密码产生密钥流的一个主要组成部分。GF(2)上一个n级反馈移位寄存器由n个二元存储器与一个反馈函数f(a1,a2,…,an)组成,如下图所示: 在任意时刻,这些级的内容构成该反馈移位寄存器...
  • FPGA学习线性反馈移位寄存器(LFSR) 最近在学习FPGA的各种计数器的时候遇到了LFSR(线性反馈移位寄存器),感觉学起来还是比较难,在这里做个记录。。 刚开始接触LFSR真的是很难理解它,包括二进制数的各个Bit的...
  • 第十讲 线性反馈移位寄存器

    千次阅读 多人点赞 2020-07-27 18:34:39
    1反馈移位寄存器(Feedback shift register,FSR) 移位寄存器是流密码产生密钥流的一个主要组成部分。 GF(2)上一个n级反馈移位寄存器由n个二元存储器与一个反馈函数组成,如下图所示。 反馈移位寄存器的状态 ...
  • 若是a1, a2, ..., an 的线性函数,则称之为线性反馈移位寄存器(Linear Feedback Shift Register, LSFR),则 f 可写为 反馈函数是n元布尔函数,即n个变元 a1, a2, a3, ..., an 可以独立的取0和1这两个可能的值...
  • 文章目录反馈移位寄存器线性反馈移位寄存器 反馈移位寄存器 移位寄存器是流密码产生密钥流的一个主要组成部分。 GF(2)上一个n级反馈移位寄存器由n个二元存储器与一个反馈函数 f(a1,a2,…,an)组成,如下图所示。 ...
  • 移位密码和乘法密码All around us data is transferred faster than ever. Sensitive data is also part of our everyday life. To protect that data, we use encryption. When we encrypt data, it changes in ...
  • LFSR代表线性反馈移位寄存器,它是一种在FPGA内部有用的设计。 LFSR易于合成,这意味着它们占用的资源相对较少,并且可以在FPGA内部以很高的时钟速率运行。
  • 一、线性反馈移位寄存器(LFSR) 通过对事先选定的种子做运算使得人工生成的伪随机序列的过程,在实际中,随机种子的选择决定了输出的伪随机序列的不同,也就是说随机种子的选择至关重要。 产生伪随机数的方法最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,212
精华内容 1,684
关键字:

线性反馈移位寄存器