Desain LFSR yang Efisien dalam FPGA Menggunakan VHDL &Verilog

LFSR dalam FPGA – VHDL &Kode Verilog

Cara kerja Register Pergeseran Umpan Balik Linier di dalam FPGA

LFSR adalah singkatan dari Linear Feedback Shift Register dan merupakan desain yang berguna di dalam FPGA. LFSR mudah untuk disintesis, artinya LFSR memerlukan sumber daya yang relatif sedikit dan dapat dijalankan pada kecepatan clock yang sangat tinggi di dalam FPGA. Ada banyak aplikasi yang mendapat manfaat dari penggunaan LFSR termasuk:

• Penghitung
• Menguji Generator Pola
• Pengacakan Data
• Kriptografi

Register geser umpan balik linier diimplementasikan sebagai serangkaian Flip-Flop di dalam FPGA yang dihubungkan bersama sebagai register geser. Beberapa ketukan pada rantai register geser digunakan sebagai input ke XOR atau XNOR gerbang. Output dari gerbang ini kemudian digunakan sebagai umpan balik ke awal rantai register geser, maka Masukan di LFSR.

LFSR 5-Bit menggunakan gerbang XNOR

Saat LFSR berjalan, pola yang dihasilkan oleh masing-masing Flip-Flop bersifat pseudo-acak, artinya mendekati acak. Ini tidak sepenuhnya acak karena dari keadaan mana pun pada pola LFSR, Anda dapat memprediksi keadaan selanjutnya. Ada beberapa properti shift register yang penting untuk diperhatikan:

• Pola LFSR bersifat pseudo-acak.
• Pola keluaran bersifat deterministik. Anda dapat mengetahui keadaan selanjutnya dengan mengetahui posisi gerbang XOR serta pola saat ini.
• Pola yang seluruhnya 0 tidak dapat muncul ketika ketukan menggunakan gerbang XOR. Karena 0 yang di XOR dengan 0 akan selalu menghasilkan 0, maka LFSR akan berhenti berjalan.
• Pola semua 1 tidak dapat muncul ketika ketukan menggunakan gerbang XNOR. Karena 1 XNOR dengan 1 akan selalu menghasilkan 1, LFSR akan berhenti berjalan.
• Jumlah maksimum iterasi yang mungkin terjadi pada LFSR mana pun =2Bits-1

LFSR yang lebih panjang akan membutuhkan waktu lebih lama untuk menjalankan semua iterasi. Jumlah iterasi terlama yang mungkin untuk LFSR N-bit adalah 2N-1. Jika Anda memikirkannya, semua kemungkinan pola dari sesuatu yang panjangnya N-bit adalah 2N. Oleh karena itu hanya ada satu pola yang tidak dapat diungkapkan dengan menggunakan LFSR. Polanya adalah semua 0 saat menggunakan gerbang XOR, atau semua 1 saat menggunakan gerbang XNOR sebagai gerbang umpan balik Anda.

Kode VHDL dan Verilog menciptakan LFSR lebar N-Bit apa pun yang Anda inginkan. Ia menggunakan polinomial (yang merupakan matematika di balik LFSR) untuk membuat panjang LFSR maksimum yang mungkin untuk setiap lebar bit. Oleh karena itu, untuk 3 bit, dibutuhkan 23-1=7 jam untuk menjalankan semua kemungkinan kombinasi, untuk 4 bit:24-1=15, untuk 5 bit:25-1=31, dll. Saya mendasarkan ini pada implementasi XNOR untuk memungkinkan FPGA memulai dalam keadaan semua-nol di LFSR. Berikut adalah tabel lengkap semua pola LFSR yang diterbitkan oleh Xilinx.

Implementasi VHDL:

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 

Meja Tes (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;

Implementasi Verilog:

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 

Meja Tes (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