Effizientes LFSR-Design in FPGA mit VHDL und Verilog

LFSR in einem FPGA – VHDL- und Verilog-Code

Wie ein lineares Feedback-Schieberegister in einem FPGA funktioniert

LFSR steht für Linear Feedback Shift Register und ist ein Design, das in FPGAs nützlich ist. LFSRs sind einfach zu synthetisieren, was bedeutet, dass sie relativ wenig Ressourcen beanspruchen und mit sehr hohen Taktraten innerhalb eines FPGA ausgeführt werden können. Es gibt viele Anwendungen, die von der Verwendung eines LFSR profitieren, darunter:

• Zähler
• Mustergeneratoren testen
• Datenverschlüsselung
• Kryptographie

Das Schieberegister mit linearer Rückkopplung ist als eine Reihe von Flip-Flops innerhalb eines FPGA implementiert, die als Schieberegister miteinander verdrahtet sind. Mehrere Abgriffe der Schieberegisterkette werden als Eingaben für entweder ein XOR verwendet oder XNOR Tor. Der Ausgang dieses Gatters wird dann als Feedback verwendet zum Anfang der Schieberegisterkette, daher das Feedback in LFSR.

5-Bit-LFSR mit XNOR-Gattern

Wenn ein LFSR ausgeführt wird, ist das von den einzelnen Flip-Flops erzeugte Muster pseudozufällig, was bedeutet, dass es nahezu zufällig ist. Es ist nicht völlig zufällig, da Sie von jedem Zustand des LFSR-Musters aus den nächsten Zustand vorhersagen können. Es gibt einige Eigenschaften von Schieberegistern, die es zu beachten gilt:

• LFSR-Muster sind pseudozufällig.
• Ausgabemuster sind deterministisch. Sie können den nächsten Zustand herausfinden, indem Sie die Position der XOR-Gatter sowie das aktuelle Muster kennen.
• Ein Muster aus nur Nullen kann nicht erscheinen, wenn die Abgriffe XOR-Gatter verwenden. Da 0 mit 0 XOR-verknüpft wird, ergibt sich immer 0, und das LFSR wird nicht mehr ausgeführt.
• Ein Muster aus nur Einsen kann nicht erscheinen, wenn die Abgriffe XNOR-Gatter verwenden. Da 1 XNOR mit 1 immer 1 ergibt, wird das LFSR nicht mehr ausgeführt.
• Die maximal mögliche Anzahl von Iterationen eines beliebigen LFSR =2Bits-1

Bei längeren LFSRs dauert es länger, alle Iterationen zu durchlaufen. Die größtmögliche Anzahl von Iterationen für ein LFSR mit N-Bits beträgt 2N-1. Wenn Sie darüber nachdenken, sind alle möglichen Muster von etwas, das N Bits lang ist, 2N. Daher gibt es nur ein Muster, das nicht mit einem LFSR ausgedrückt werden kann. Dieses Muster besteht nur aus Nullen, wenn Sie XOR-Gatter verwenden, oder nur aus Einsen, wenn Sie XNOR-Gatter als Rückkopplungsgatter verwenden.

Der VHDL- und Verilog-Code erstellt jedes N-Bit breite LFSR, das Sie wünschen. Es verwendet Polynome (die Mathematik hinter dem LFSR), um die maximal mögliche LFSR-Länge für jede Bitbreite zu erstellen. Daher sind für 3 Bits 23-1=7 Takte erforderlich, um alle möglichen Kombinationen zu durchlaufen, für 4 Bits:24-1=15, für 5 Bits:25-1=31 usw. Ich habe dies auf einer XNOR-Implementierung basiert, um dem FPGA zu ermöglichen, in einem All-Null-Zustand auf dem LFSR zu starten. Hier ist die vollständige Tabelle aller von Xilinx veröffentlichten LFSR-Muster.

VHDL-Implementierung:

LFSR.vhd

-------------------------------------------------------------------------------
-- File downloaded from http://www.nandland.com
-------------------------------------------------------------------------------
-- Description:
-- A LFSR or Linear Feedback Shift Register is a quick and easy
-- way to generate pseudo-random data inside of an FPGA. The LFSR can be used
-- for things like counters, test patterns, scrambling of data, and others.
-- This module creates an LFSR whose width gets set by a generic. The
-- o_LFSR_Done will pulse once all combinations of the LFSR are complete. The
-- number of clock cycles that it takes o_LFSR_Done to pulse is equal to
-- 2^g_Num_Bits-1. For example, setting g_Num_Bits to 5 means that o_LFSR_Done
-- will pulse every 2^5-1 = 31 clock cycles. o_LFSR_Data will change on each
-- clock cycle that the module is enabled, which can be used if desired.
--
-- Generics:
-- g_Num_Bits - Set to the integer number of bits wide to create your LFSR.
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
entity LFSR is
 generic (
 g_Num_Bits : integer := 5
 );
 port (
 i_Clk : in std_logic;
 i_Enable : in std_logic;
 -- Optional Seed Value
 i_Seed_DV : in std_logic;
 i_Seed_Data : in std_logic_vector(g_Num_Bits-1 downto 0);
 
 o_LFSR_Data : out std_logic_vector(g_Num_Bits-1 downto 0);
 o_LFSR_Done : out std_logic
 );
end entity LFSR;
architecture RTL of LFSR is
 signal r_LFSR : std_logic_vector(g_Num_Bits downto 1) := (others => '0');
 signal w_XNOR : std_logic;
 
begin
 -- Purpose: Load up LFSR with Seed if Data Valid (DV) pulse is detected.
 -- Othewise just run LFSR when enabled.
 p_LFSR : process (i_Clk) is
 begin
 if rising_edge(i_Clk) then
 if i_Enable = '1' then
 if i_Seed_DV = '1' then
 r_LFSR 

Testbench (LFSR_TB.vhd)

-------------------------------------------------------------------------------
-- File downloaded from http://www.nandland.com
-------------------------------------------------------------------------------
-- Description: Simple Testbench for LFSR.vhd. Set c_NUM_BITS to different
-- values to verify operation of LFSR
-------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
entity LFSR_TB is
end entity LFSR_TB;
architecture behave of LFSR_TB is
 constant c_NUM_BITS : integer := 5;
 constant c_CLK_PERIOD : time := 40 ns; -- 25 MHz
 
 signal r_Clk : std_logic := '0';
 signal w_LFSR_Data : std_logic_vector(c_NUM_BITS-1 downto 0);
 signal w_LFSR_Done : std_logic;
 
begin
 r_Clk c_NUM_BITS)
 port map (
 i_Clk => r_Clk,
 i_Enable => '1',
 i_Seed_DV => '0',
 i_Seed_Data => (others => '0'),
 o_LFSR_Data => w_LFSR_Data,
 o_LFSR_Done => w_LFSR_Done
 );
 
end architecture behave;

Verilog-Implementierung:

LFSR.v

///////////////////////////////////////////////////////////////////////////////
// File downloaded from http://www.nandland.com
///////////////////////////////////////////////////////////////////////////////
// Description: 
// A LFSR or Linear Feedback Shift Register is a quick and easy way to generate
// pseudo-random data inside of an FPGA. The LFSR can be used for things like
// counters, test patterns, scrambling of data, and others. This module
// creates an LFSR whose width gets set by a parameter. The o_LFSR_Done will
// pulse once all combinations of the LFSR are complete. The number of clock
// cycles that it takes o_LFSR_Done to pulse is equal to 2^g_Num_Bits-1. For
// example setting g_Num_Bits to 5 means that o_LFSR_Done will pulse every
// 2^5-1 = 31 clock cycles. o_LFSR_Data will change on each clock cycle that
// the module is enabled, which can be used if desired.
//
// Parameters:
// NUM_BITS - Set to the integer number of bits wide to create your LFSR.
///////////////////////////////////////////////////////////////////////////////
module LFSR #(parameter NUM_BITS)
 (
 input i_Clk,
 input i_Enable,
 // Optional Seed Value
 input i_Seed_DV,
 input [NUM_BITS-1:0] i_Seed_Data,
 output [NUM_BITS-1:0] o_LFSR_Data,
 output o_LFSR_Done
 );
 reg [NUM_BITS:1] r_LFSR = 0;
 reg r_XNOR;
 // Purpose: Load up LFSR with Seed if Data Valid (DV) pulse is detected.
 // Othewise just run LFSR when enabled.
 always @(posedge i_Clk)
 begin
 if (i_Enable == 1'b1)
 begin
 if (i_Seed_DV == 1'b1)
 r_LFSR 

Testbench (LFSR_TB.v)

///////////////////////////////////////////////////////////////////////////////
// File downloaded from http://www.nandland.com
///////////////////////////////////////////////////////////////////////////////
// Description: Simple Testbench for LFSR.v. Set c_NUM_BITS to different
// values to verify operation of LFSR
///////////////////////////////////////////////////////////////////////////////
module LFSR_TB ();
 parameter c_NUM_BITS = 4;
 
 reg r_Clk = 1'b0;
 
 wire [c_NUM_BITS-1:0] w_LFSR_Data;
 wire w_LFSR_Done;
 
 LFSR #(.NUM_BITS(c_NUM_BITS)) LFSR_inst
 (.i_Clk(r_Clk),
 .i_Enable(1'b1),
 .i_Seed_DV(1'b0),
 .i_Seed_Data(}), // Replication
 .o_LFSR_Data(w_LFSR_Data),
 .o_LFSR_Done(w_LFSR_Done)
 );
 
 always @(*)
 #10 r_Clk