Cara membagi 50MHz ke 2Hz di VHDL pada Xilinx FPGA

Saya memiliki papan Xilinx FPGA, dengan kristal 50MHz. Saya perlu membaginya menjadi 2Hz di VHDL. Bagaimana saya melakukan ini?

Pada dasarnya, ada dua cara untuk melakukan ini. Yang pertama adalah menggunakan inti synthesizer clock asli Xilinx. Salah satu keuntungannya adalah alat Xlinx akan mengenali jam seperti itu dan merutekannya melalui jalur yang diperlukan. Alat ini juga akan menangani kendala waktu apa pun (tidak benar-benar berlaku dalam kasus ini, karena ini adalah jam 2Hz)

Cara kedua adalah menggunakan penghitung untuk menghitung jumlah pulsa clock yang lebih cepat hingga setengah dari periode clock Anda yang lebih lambat berlalu. Misalnya, untuk kasus Anda, jumlah pulsa clock cepat yang membentuk satu periode clock dari siklus clock lambat adalah 50000000/2 = 25000000. Karena kami ingin setengah periode clock, itu 25000000/2 = 12500000 untuk setiap setengah siklus . (durasi masing-masing tinggi atau rendah).

Begini tampilannya di VHDL:

library IEEE;
use IEEE.STD_LOGIC_1164.all;

-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
use IEEE.NUMERIC_STD.all;

entity scale_clock is
  port (
    clk_50Mhz : in  std_logic;
    rst       : in  std_logic;
    clk_2Hz   : out std_logic);
end scale_clock;

architecture Behavioral of scale_clock is

  signal prescaler : unsigned(23 downto 0);
  signal clk_2Hz_i : std_logic;
begin

  gen_clk : process (clk_50Mhz, rst)
  begin  -- process gen_clk
    if rst = '1' then
      clk_2Hz_i   <= '0';
      prescaler   <= (others => '0');
    elsif rising_edge(clk_50Mhz) then   -- rising clock edge
      if prescaler = X"BEBC20" then     -- 12 500 000 in hex
        prescaler   <= (others => '0');
        clk_2Hz_i   <= not clk_2Hz_i;
      else
        prescaler <= prescaler + "1";
      end if;
    end if;
  end process gen_clk;

clk_2Hz <= clk_2Hz_i;

end Behavioral;

Hal yang perlu diperhatikan:

• Jam yang dihasilkan adalah nol selama reset. Ini ok untuk beberapa aplikasi, dan tidak untuk yang lain, itu hanya tergantung apa yang Anda butuhkan untuk jam.
• Jam yang dihasilkan akan dialihkan sebagai sinyal normal oleh alat sintesis Xilinx.
• 2Hz sangat lambat. Simulasi sebentar akan membutuhkan waktu. Ini adalah sejumlah kecil kode, sehingga harus relatif cepat untuk mensimulasikan bahkan selama 1 detik, tetapi jika Anda mulai menambahkan kode, waktu yang dibutuhkan untuk mensimulasikan siklus clock 2 Hz bisa sangat lama.

EDIT: clk_2Hz_i digunakan untuk buffer sinyal output. VHDL tidak suka menggunakan sinyal di sebelah kanan tugas ketika itu juga merupakan output.

Gunakan prescaler jam.

Nilai prescaler Anda akan menjadi Anda (clock_speed / diinginkan_clock_speed) / 2 so (50Mhz (50.000.000) / 2hz (2)) / 2 = 12.500.000 yang dalam biner adalah 101111101011110000100000000.

Lebih sederhana: (50.000.000) / 2) / 2 = 12.500.000 dikonversi ke biner -> 101111101011110000100000000

Berikut adalah beberapa kode yang harus dilakukan: Gunakan newClock untuk apa pun yang Anda butuhkan 2hz untuk ...

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity ClockPrescaler is
    port(
        clock   : in STD_LOGIC; -- 50 Mhz
        Led     : out STD_LOGIC
    );
end ClockPrescaler;

architecture Behavioral of ClockPrescaler is
    -- prescaler should be (clock_speed/desired_clock_speed)/2 because you want a rising edge every period
    signal prescaler: STD_LOGIC_VECTOR(23 downto 0) := "101111101011110000100000"; -- 12,500,000 in binary
    signal prescaler_counter: STD_LOGIC_VECTOR(23 downto 0) := (others => '0');
    signal newClock : std_logic := '0';
begin

    Led <= newClock;

    countClock: process(clock, newClock)
    begin
        if rising_edge(clock) then
            prescaler_counter <= prescaler_counter + 1;
            if(prescaler_counter > prescaler) then
                -- Iterate
                newClock <= not newClock;

                prescaler_counter <= (others => '0');
            end if;
        end if;
    end process;


end Behavioral;

Anda biasanya tidak benar-benar ingin clock apa pun yang lambat, buat saja sebuah mengaktifkan pada tingkat yang benar dan menggunakannya dalam logika:

 if rising_edge(50MHz_clk) and enable = '1' then

Anda dapat membuat mengaktifkan dengan demikian:

process 
   variable count : natural;
begin
   if rising_edge(50MHz_clk) then
       enable <= '0';
       count := count + 1;
       if count = clock_freq/desired_freq then
          enable <= '1';
          count := 0;
       end if;
    end if;
end process;

buat beberapa konstanta dengan frekuensi jam Anda dan frekuensi aktifkan yang diinginkan dan pergilah, dengan kode dokumentasi sendiri untuk boot.

Saya lebih suka menyarankan menggunakan Xilinx primitice digital clock manager IP .

Ini memiliki antarmuka pengaturan grafis di mana Anda dapat menentukan frekuensi apa yang Anda inginkan. Ini akan menghasilkan komponen dengan output yang Anda inginkan sebagai frekuensi.

Itu dapat ditemukan di IP Wizard;

Dan kemudian Anda akan dapat menentukan frekuensi apa yang Anda inginkan:

Faktor = frekuensi-sinyal-input-input / output-prescaler-frekuensi.

CE = Clock Enable. Seharusnya pulsa lebar satu jam (clk) atau tinggi jika tidak digunakan.

T = Sinyal keluaran pulsa lebar satu jam dengan frekuensi yang diinginkan.

library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.STD_LOGIC_ARITH.all;
use IEEE.STD_LOGIC_UNSIGNED.all;

entity prescaler is

  generic (
    FACTOR : integer);

  port (
    clk : in  std_logic;
    rst : in  std_logic;
    CE  : in  std_logic;
    Q   : out std_logic);

end prescaler;

architecture for_prescaler of prescaler is
  signal counter_reg, counter_next : integer range 0 to FACTOR-1;
  signal Q_next: std_logic;
begin  -- for_prescaler

  process (clk, rst)
  begin  -- process
    if rst = '1' then                   -- asynchronous reset (active low)
      counter_reg <= 0;
    elsif clk'event and clk = '1' then  -- rising clock edge
      counter_reg <= counter_next;
    end if;
  end process;

  process (counter_reg, CE)
  begin  -- process
    Q_next <= '0';
     counter_next <= counter_reg;
     if CE = '1' then
        if counter_reg = FACTOR-1  then
          counter_next <= 0;
           Q_next <= '1';
         else
           counter_next <= counter_reg + 1;
        end if;
      end if;
  end process;

  process (clk, rst)
  begin  -- process
    if rst = '1' then                   -- asynchronous reset (active low)
      Q <= '0';
    elsif clk'event and clk = '1' then  -- rising clock edge
      Q <= Q_next;
    end if;
  end process; 

end for_prescaler;