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

Dalam Pelajaran 3, anda membina litar yang mengingati satu bit atau satu bait: flip-flop dan daftar muatan selari. Setiap satunya mengemas kini nilai tersimpan pada pinggir jam. Dalam pelajaran ini, anda menggunakan semula idea itu untuk membina litar yang bergerak sendiri pada setiap pinggir: pembilang yang meningkat melalui 0, 1, 2, 3, … dan daftar anjakan yang menggerakkan bitnya ke sisi.

Jam papan ialah CLOCK_50, gelombang segi empat 50 MHz dengan 50,000,000 pinggir menaik setiap saat. Jika pembilang bergerak sekali pada setiap pinggir CLOCK_50, ia akan melalui kesemua enam belas nilai pembilang 4 bit kira-kira tiga juta kali sesaat. Anda hanya akan melihat kabur LED yang kelihatan tetap, dan kamera jauh yang menangkap beberapa bingkai sesaat langsung tidak dapat mengikutinya.

Oleh itu, kita memperlahankan litar menggunakan pembahagi jam. Pembahagi jam itu sendiri hanyalah sebuah pembilang: ia mengira pinggir CLOCK_50 dan, apabila mencapai kiraan terminal pilihan DIV, ia menyongsangkan isyarat lebih perlahan bernama slow_clk lalu mula mengira semula. Semakin besar DIV, semakin perlahan slow_clk. Kemudian litar *sebenar* — pembilang 4 bit atau daftar anjakan — dipacu oleh slow_clk, bukan CLOCK_50.

Seperti dalam setiap pelajaran, reka bentuk jujukan mesti mengisytiharkan jam sendiri. Templat lalai leds_mirror.v hanya menyenaraikan suis, butang dan LED serta tidak mempunyai jam, jadi setiap modul dalam pelajaran ini menambah input CLOCK_50; pada senarai port. Isyarat papan kekal sama: SW[9:0], dengan suis dinaikkan mewakili 1; KEY[3:0], aktif-rendah, jadi butang ditekan dibaca sebagai 0; LEDR[9:0], aktif-tinggi, menyala apabila dipacu 1; dan HEX0–HEX5, paparan tujuh segmen aktif-rendah yang segmennya menyala apabila dipacu 0.

Pembilang ialah daftar yang nilai berikutnya hanyalah nilai semasa ditambah satu. Pembilang 4 bit menyimpan nilai 0 hingga 15; selepas 15, ia melilit semula kepada 0 secara automatik kerana 15 + 1 = 16 = 10000 dalam perduaan dan hanya empat bit rendah disimpan, iaitu 0000. Anda tidak memerlukan kod khas untuk pelilitan ini; lebar daftar melakukannya untuk anda.

Reka bentuk di bawah mempunyai dua bahagian. Pembahagi mengira pinggir CLOCK_50 hingga DIV dan menyongsangkan slow_clk. Pembilang meningkat satu pada setiap pinggir menaik slow_clk, manakala KEY[0] menetapkannya semula kepada 0; kerana butang ini aktif-rendah, menahannya mengaktifkan set semula. Kiraan memacu LEDR[3:0] dalam perduaan dan turut memacu HEX0 sebagai satu digit perenambelasan: 0–9, kemudian A–F bagi 10–15.

Pemasaan dengan tepat. Dengan DIV = 33,333,333, pembahagi menyongsangkan slow_clk selepas kira-kira 0.67 saat, kerana 33,333,333 pinggir daripada 50,000,000 sesaat bersamaan lebih kurang dua pertiga saat. Langkah pembilang hanya berlaku pada pinggir menaik slow_clk, dan gelombang segi empat mempunyai satu pinggir menaik bagi setiap *tempoh penuh*: satu perubahan rendah ke tinggi dan satu perubahan tinggi ke rendah. Maka pembilang meningkat kira-kira sekali setiap 1.33 saat, bersamaan kira-kira 0.75 Hz. Jangkakan nilai baharu sedikit kurang daripada sekali sesaat.

Masalah lebar daftar. Daftar pembahagi di sini sengaja selebar 27 bit. Daftar 26 bit hanya boleh menyimpan nilai hingga 2^26 - 1 = 67,108,863. Nilai seperti DIV = 100,000,000 langsung tidak muat dalam 26 bit, jadi reka bentuk dengan lebar itu sudah rosak sebelum dijalankan. Dengan 27 bit, daftar boleh menyimpan hingga 2^27 - 1 = 134,217,727; oleh itu DIV = 100,000,000, yang lebih perlahan, dan DIV = 8,333,333, yang lebih pantas, kedua-duanya muat dan berfungsi. Sentiasa pastikan pemalar muat dalam daftar yang diisytiharkan.

Satu peringatan penting. Memacu daftar terus daripada slow_clk terbahagi seperti yang dilakukan di sini ialah jalan pintas pengajaran yang lazim kerana ia menjadikan idea mudah dilihat. Dalam reka bentuk pengeluaran, semua logik biasanya dikekalkan pada satu jam pantas CLOCK_50 dan menggunakan isyarat pemboleh jam (*clock-enable*): denyut satu kitaran yang memberitahu daftar “kemas kini pada pinggir ini”. Dengan itu, seluruh reka bentuk kekal pada satu jam sebenar yang dapat dianalisis jauh lebih baik oleh alat sintesis. Kita menggunakan jam terbahagi di sini hanya kerana ia cara paling jelas untuk *melihat* pembilang bergerak.

// Pelajaran 4 - Latihan 2-C: templat awal pembilang 4 bit dengan pembahagi jam
// KEY[0]=set semula. LEDR[3:0]=kiraan, HEX0=kiraan sebagai digit perenambelasan.
module leds_mirror(CLOCK_50, KEY, LEDR, HEX0);
    input        CLOCK_50;
    input  [3:0] KEY;
    output [9:0] LEDR;
    output [6:0] HEX0;

    localparam [26:0] DIV = TODO_DIVIDER_LIMIT;
    reg [26:0] div;
    reg        slow_clk;

    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    reg [3:0] count;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) count <= TODO_RESET_COUNT;
        else         count <= TODO_NEXT_COUNT;
    end

    assign LEDR[3:0] = TODO_LED_COUNT;
    assign LEDR[9:4] = 6'b0;
    assign HEX0 = TODO_HEX_PATTERN_FOR_COUNT;
endmodule

Bina pembilang pada papan sebenar, perhatikan nilainya meningkat, tetapkan semula dan kemudian cuba dua nilai pembahagi lain.

Hantar bukti anda. Tunggu sehingga HEX0 menunjukkan digit C, iaitu perpuluhan 12, ambil tangkapan kamera — LEDR[3:0] sepatutnya menunjukkan 1100 pada masa yang sama — dan lampirkannya di bawah.

Pembilang 4 bit biasa melalui 0–15 dan menunjukkan A–F bagi enam nilai tertinggi. Banyak paparan sebenar memerlukan satu digit perpuluhan sahaja: kira 0, 1, 2, …, 9, kemudian kembali terus kepada 0. Pembilang yang hanya mengira 0–9 dipanggil pembilang BCD, iaitu perpuluhan berkod perduaan.

Perubahannya kecil: daripada membiarkan daftar 4 bit melilit sendiri selepas 15, anda mengesan apabila kiraan mencapai 9 dan memaksa nilai berikutnya menjadi 0. Gantikan blok always pembilang dengan logik berbentuk berikut:

reg [3:0] count;
always @(posedge slow_clk or negedge KEY[0]) begin
    if (!KEY[0])           count <= TODO_RESET_COUNT;
    else if (count == TODO_LAST_BCD_DIGIT) count <= TODO_WRAP_VALUE;
    else                   count <= TODO_NEXT_COUNT;
end

Kekalkan semua bahagian lain — pembahagi, penetapan LEDR/HEX0 dan fungsi seg — tanpa perubahan. Kini HEX0 sepatutnya melalui 0 hingga 9 dan tidak pernah menunjukkan A–F.

Daftar anjakan ialah sebaris flip-flop yang, pada setiap pinggir jam, memindahkan setiap bit kepada jirannya dan menerima satu bit baharu pada salah satu hujung. Daftar ini penting dalam pautan bersiri: protokol seperti UART, SPI dan I2C menghantar data satu bit pada satu masa, dan daftar anjakan mengumpulkan bit itu menjadi satu bait atau memisahkan satu bait bit demi bit.

Reka bentuk di bawah menggunakan daftar 8 bit shreg[7:0]. Pada setiap pinggir menaik slow_clk, selagi anjakan didayakan, ia melaksanakan:

shreg <= TODO_SHIFT_LEFT_UPDATE;   // anjak ke kiri dan masukkan SW[0] ke bit yang betul

Baca sebelah kanan dengan teliti: ia mengambil tujuh bit rendah shreg[6:0], menggerakkannya satu kedudukan ke atas dan memasukkan SW[0] ke bit 0. Setiap bit bergerak ke arah hujung tinggi, maka ini ialah anjakan kiri. Kawalannya ialah SW[0] = bit bersiri masuk, KEY[0] = set semula aktif-rendah dan KEY[1] = pemboleh anjakan aktif-rendah: tahan KEY[1] untuk menganjak pada setiap detik.

Corak yang dijangka. Gunakan penaakulan dan jangan bergantung pada orientasi kamera. Mulakan dengan 0000_0000. Tetapkan SW[0] = 1 dan biarkan empat detik berlalu: daftar diisi daripada bit 0 ke atas, menghasilkan 0000_0001, kemudian 0000_0011, 0000_0111, 0000_1111. Sekarang tetapkan SW[0] = 0 dan biarkan empat detik lagi: sifar masuk pada bit 0 dan menolak satu ke atas lalu keluar, menghasilkan 0001_1110, 0011_1100, 0111_1000 dan akhirnya 1111_0000. Jadi selepas empat 1 diikuti empat 0, shreg[7:0] ialah 1111_0000.

Nilai bit berbanding perkara yang anda lihat. Catat kedua-dua nilai perduaan daftar dan perkara yang ditunjukkan kamera. Susunan fizikal LED pada papan mungkin kelihatan tercermin berbanding cara bit ditulis, dengan shreg[7] di satu hujung dan shreg[0] di hujung lain. Oleh itu, LED menyala boleh kelihatan terbalik kiri ke kanan berbanding nombor 1111_0000. Itu kesan pelabelan dan orientasi, bukan ralat logik; sebab itulah anda perlu mencatat nilai yang dikira bersama-sama foto.

// Pelajaran 4 - Latihan 2-D: templat awal daftar anjakan 8 bit
// SW[0]=data bersiri masuk, KEY[0]=set semula, KEY[1]=pemboleh anjakan.
module leds_mirror(CLOCK_50, SW, KEY, LEDR);
    input        CLOCK_50;
    input  [9:0] SW;
    input  [3:0] KEY;
    output [9:0] LEDR;

    localparam [24:0] DIV = TODO_DIVIDER_LIMIT;
    reg [24:0] div;
    reg        slow_clk;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    reg [7:0] shreg;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0])      shreg <= TODO_RESET_VECTOR;
        else if (!KEY[1]) shreg <= TODO_SHIFT_LEFT_UPDATE;
    end

    assign LEDR[7:0] = TODO_SHIFT_REGISTER_OUTPUT;
    assign LEDR[9:8] = 2'b00;
endmodule

Bina daftar anjakan, perhatikan satu LED menyala bergerak sepanjang baris, kemudian lihat sifar mengikutinya.

Hantar bukti anda. Selepas empat detik SW0=1 diikuti empat detik SW0=0, lepaskan KEY[1] untuk membekukan corak, shreg = 1111_0000, ambil tangkapan kamera, catat sama ada LED menyala kelihatan tercermin dan lampirkannya di bawah.

Anjak ke arah yang satu lagi. Untuk membuat daftar beranjak ke kanan dan bukan ke kiri — setiap bit bergerak ke arah hujung rendah, dengan bit baharu masuk pada hujung tinggi, shreg[7] — anda hanya perlu mengubah satu baris. Gantikan ruang letak anjakan kiri dengan ungkapan anjakan kanan anda sendiri.

else if (!KEY[1]) shreg <= TODO_SHIFT_RIGHT_UPDATE;   // anjak kanan dan masukkan SW[0]

Hanya baris itu berubah. Kini SW[0] masuk ke shreg[7], manakala tujuh bit tinggi shreg[7:1] bergerak turun ke shreg[6:0].

Lanjutan — pembilang gelang. Pembilang gelang menyuap balik output daftar sendiri ke inputnya dan bukan menerima bit luaran baharu, jadi satu corak tetap beredar selama-lamanya. Bina gelang beranjak kiri yang menyuap balik bit teratas ke bit terendah. Mulakan daftar pada 0000_0001 supaya tepat satu LED menyala mengejar sepanjang baris. Gunakan set semula yang memuat 8'h01, bukan 8'h00. Tahan KEY[1] dan perhatikan satu LED beredar tanpa henti.