Logik digital pada DE1-SoC dengan VHDL (4/6): pembilang dan daftar anjakan pilihan

Dalam Pelajaran 3, anda membina litar yang mengingati satu bit atau bait: flip-flop dan daftar muatan selari. Setiap satu mengemas kini nilai tersimpan pada pinggir jam. Kini anda menggunakan semula idea itu untuk membina litar yang bergerak sendiri pada setiap pinggir: pembilang yang maju 0, 1, 2, 3, .... Jika masa mengizinkan, sambungan pilihan menggunakan prinsip yang sama untuk daftar anjakan, yang menggerakkan bit ke sisi.

Jam CLOCK_50 papan ialah gelombang 50 MHz dengan 50,000,000 pinggir menaik sesaat. Jika pembilang 4 bit maju pada setiap pinggir, ia akan menghabiskan semua 16 nilai kira-kira tiga juta kali sesaat. LED hanya kelihatan kabur dan kamera jauh tidak sempat menunjukkan setiap langkah.

Oleh itu, kita menggunakan pembahagi jam. Pembahagi mengira pinggir CLOCK_50; apabila mencapai kiraan terminal DIV, ia menyongsangkan isyarat perlahan slow_clk dan mula mengira semula. Semakin besar DIV, semakin perlahan slow_clk. Litar utama dipacu oleh slow_clk, bukan terus oleh CLOCK_50, supaya gerakannya dapat dilihat.

Reka bentuk jujukan perlu mengisytiharkan jam. Templat blink.vhd tidak menyertakannya, maka setiap entiti dalam pelajaran ini menambah CLOCK_50 : in std_logic. Isyarat lain ialah SW(9 downto 0) (suis ke atas = 1), KEY(3 downto 0) (aktif-rendah: ditekan = 0), LEDR(9 downto 0) (aktif-tinggi) dan HEX0–HEX5 (tujuh segmen aktif-rendah).

Pembilang ialah daftar yang nilai seterusnya bersamaan nilai semasa tambah satu. Pembilang 4 bit menyimpan 0 hingga 15; selepas 15, ia kembali ke 0 secara automatik kerana 15 + 1 = 10000 dalam perduaan dan hanya empat bit rendah (0000) disimpan.

Reka bentuk ini mempunyai dua bahagian. Pembahagi mengira pinggir CLOCK_50 hingga DIV dan menyongsangkan slow_clk. Pembilang bertambah satu pada setiap pinggir menaik slow_clk; KEY(0) menetapkannya semula kepada 0. Nilai dipaparkan dalam perduaan pada LEDR(3 downto 0) dan sebagai satu digit perenambelasan pada HEX0: 0–9, kemudian A–F bagi 10–15.

Pemasaan. Dengan DIV = 33,333,333, slow_clk disongsangkan selepas kira-kira 0.67 s. Satu langkah hanya berlaku pada pinggir menaik, dan gelombang segi empat memerlukan dua songsangan bagi satu tempoh penuh. Maka pembilang maju kira-kira setiap 1.33 s, iaitu lebih kurang 0.75 Hz.

Perangkap lebar daftar. Daftar pembahagi di sini selebar 27 bit. Daftar 26 bit hanya menyimpan hingga 2^26 − 1 = 67,108,863, jadi DIV = 100,000,000 tidak muat. Daftar 27 bit mencapai 2^27 − 1 = 134,217,727, maka 100,000,000 dan 8,333,333 kedua-duanya muat. Sentiasa pastikan pemalar muat dalam lebar yang diisytiharkan.

Catatan kejuruteraan. Memacu daftar terus daripada slow_clk terbahagi ialah jalan pintas pengajaran supaya gerakan jelas. Dalam reka bentuk pengeluaran, semua logik biasanya kekal pada CLOCK_50 dan menggunakan pemboleh jam, iaitu denyut satu kitaran yang membenarkan kemas kini. Ini memudahkan analisis pemasaan oleh alat sintesis.

-- Kod permulaan pelajar: lengkapkan baris TODO sebelum sintesis.
-- Pelajaran 4 - Latihan 2-C: pembilang 4 bit dengan pembahagi jam.
-- KEY(0)=set semula. LEDR(3 downto 0)=kiraan; HEX0=kiraan perenambelasan.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        LEDR     : out std_logic_vector(9 downto 0);
        HEX0     : out std_logic_vector(6 downto 0)
    );
end entity blink;

architecture rtl of blink is
    constant DIV : unsigned(26 downto 0) := TODO_VISIBLE_DIVIDER;
    signal div_count : unsigned(26 downto 0) := (others => '0');
    signal slow_clk  : std_logic := '0';
    signal count     : unsigned(3 downto 0) := (others => '0');

    function seg(d : unsigned(3 downto 0)) return std_logic_vector is
    begin
        case d is
            when "0000" => return "1000000"; when "0001" => return "1111001";
            when "0010" => return "0100100"; when "0011" => return "0110000";
            when "0100" => return "0011001"; when "0101" => return "0010010";
            when "0110" => return "0000010"; when "0111" => return "1111000";
            when "1000" => return "0000000"; when "1001" => return "0010000";
            when "1010" => return "0001000"; when "1011" => return "0000011";
            when "1100" => return "1000110"; when "1101" => return "0100001";
            when "1110" => return "0000110"; when "1111" => return "0001110";
            when others => return "1111111";
        end case;
    end function;
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0');
                slow_clk <= '0';
            elsif div_count = TODO_DIVIDER_LIMIT then
                div_count <= (others => '0');
                slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then count <= (others => '0');
        elsif rising_edge(slow_clk) then count <= TODO_NEXT_COUNT;
        end if;
    end process;

    LEDR(3 downto 0) <= TODO_LED_COUNT;
    LEDR(9 downto 4) <= (others => '0');
    HEX0 <= TODO_HEX_COUNT;
end architecture rtl;

Bina pembilang pada papan sebenar, perhatikan ia maju, tetapkan semula, kemudian cuba dua nilai pembahagi lain.

Hantar bukti. Apabila HEX0 menunjukkan C (perpuluhan 12), ambil tangkap layar kamera; LEDR(3 downto 0) mesti menunjukkan 1100 pada masa yang sama.

Pembilang 4 bit biasa bergerak 0–15 dan menunjukkan A–F bagi enam nilai terakhir. Banyak paparan hanya memerlukan satu digit perpuluhan: 0, 1, 2, …, 9, kemudian kembali ke 0. Ini ialah pembilang BCD (perpuluhan berkod perduaan).

Daripada membiarkan daftar melilit selepas 15, kesan nilai 9 dan paksa nilai berikutnya kepada 0. Gantikan proses pembilang dengan:

process(slow_clk, KEY)
begin
    if KEY(0) = '0' then count <= TODO_RESET_COUNT;
    elsif rising_edge(slow_clk) then
        if count = TODO_LAST_BCD_DIGIT then count <= TODO_WRAP_VALUE;
        else                              count <= TODO_NEXT_COUNT;
        end if;
    end if;
end process;

Kekalkan pembahagi, tugasan serentak LEDR/HEX0 dan fungsi seg. Kini HEX0 hanya berkitar 0 hingga 9.

Daftar anjakan ialah sederet flip-flop yang memindahkan setiap bit kepada jirannya pada setiap pinggir sementara satu bit baharu masuk di hujung. Ia penting bagi pautan bersiri seperti UART, SPI dan I2C, yang menghantar data satu bit pada satu masa.

Daftar shreg(7 downto 0) menjalankan tugasan ini pada setiap pinggir menaik slow_clk apabila anjakan didayakan:

shreg <= TODO_SHIFT_LEFT_UPDATE;  -- TODO: anjak kiri dan masukkan SW(0) ke bit 0

Sebelah kanan mengambil tujuh bit rendah shreg(6 downto 0), menggerakkannya satu kedudukan ke atas dan memasukkan SW(0) ke bit 0. Semua bit bergerak ke hujung tinggi, jadi ini ialah anjakan kiri. SW(0) ialah input bersiri, KEY(0) ialah set semula dan KEY(1) ialah pemboleh anjakan; kedua-dua KEY aktif-rendah. Tahan KEY(1) untuk menganjak pada setiap detik.

Corak jangkaan. Bermula pada 0000_0000, masukkan empat 1: 0000_0001, 0000_0011, 0000_0111, 0000_1111. Kemudian masukkan empat 0: 0001_1110, 0011_1100, 0111_1000, akhirnya 1111_0000.

Nilai bit berbanding rupa. Rekod nilai perduaan dan rupa kamera. Susunan fizikal LED mungkin kelihatan terbalik berbanding penulisan bit (shreg(7) di satu sisi dan shreg(0) di sisi lain). Itu kesan orientasi, bukan ralat logik.

-- Kod permulaan pelajar: lengkapkan baris TODO sebelum sintesis.
-- Pelajaran 4 - Latihan 2-D: daftar anjakan 8 bit yang menganjak ke kiri.
-- SW(0)=input data bersiri, KEY(0)=set semula, KEY(1)=pemboleh anjakan. KEY aktif-rendah.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        SW       : in  std_logic_vector(9 downto 0);
        LEDR     : out std_logic_vector(9 downto 0)
    );
end entity blink;

architecture rtl of blink is
    constant DIV : unsigned(26 downto 0) := TODO_VISIBLE_DIVIDER;
    signal div_count : unsigned(26 downto 0) := (others => '0');
    signal slow_clk  : std_logic := '0';
    signal shreg     : std_logic_vector(7 downto 0) := (others => '0');
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0'); slow_clk <= '0';
            elsif div_count = DIV then
                div_count <= (others => '0'); slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then
            shreg <= (others => '0');
        elsif rising_edge(slow_clk) then
            if KEY(1) = '0' then shreg <= TODO_SHIFT_UPDATE;
            end if;
        end if;
    end process;

    LEDR(7 downto 0) <= TODO_SHIFT_OUTPUT;
    LEDR(9 downto 8) <= (others => '0');
end architecture rtl;

Bina daftar anjakan, lihat bit menyala bergerak sepanjang baris, kemudian lihat sifar mengikutinya.

Hantar bukti. Selepas empat 1 dan empat 0, lepaskan KEY(1) untuk membekukan shreg = 1111_0000, ambil tangkap layar dan catat sama ada LED kelihatan terbalik.

Anjak ke arah lain. Untuk menggerakkan setiap bit ke hujung rendah dan memasukkan bit baharu di bahagian atas (shreg(7)), tukar satu tugasan:

shreg <= TODO_SHIFT_RIGHT_UPDATE; -- TODO: anjak kanan dan masukkan SW(0) ke bit 7

Kini SW(0) masuk ke shreg(7) dan shreg(7 downto 1) turun ke shreg(6 downto 0).

Sambungan: pembilang gelang. Pembilang gelang menyuap balik output daftar sendiri supaya corak tetap beredar. Bina gelang anjak kiri dengan shreg(7) disuap ke bit 0. Set semula perlu memuatkan "00000001", dan baris anjakan ialah shreg <= shreg(6 downto 0) & shreg(7);. Tahan KEY(1) untuk melihat satu LED beredar.