Menggunakan Integrated Logic Analyzer (ILA) dan Virtual Input/Output (VIO)

Tutorial ini mencakup penggunaan Integrated Logic Analyzer (ILA) dan Input/Keluaran Virtual (VIO) core untuk men-debug dan memantau desain VHDL Anda di Xilinx Vivado IDE.

Dalam banyak kasus, desainer perlu melakukan verifikasi on-chip. Artinya, mendapatkan akses ke perilaku sinyal internal dalam desain FPGA mereka untuk tujuan verifikasi.

Salah satu opsi adalah membawa sinyal ini ke pin FPGA dan menghubungkannya ke LED untuk melihat perilakunya secara visual. Opsi ini mudah, cepat, dan berfungsi dengan baik untuk kasus sederhana, tetapi tidak fleksibel, skalabel, atau realistis.

Pilihan lainnya adalah memiliki penganalisis logika eksternal dengan fitur-fitur canggih yang dapat menampilkan dan menggambarkan perilaku sinyal ini, tetapi memerlukan peralatan eksternal dan relatif mahal.

Integrated Logic Analyzer (ILA) adalah alternatif yang menggabungkan keunggulan dari kedua opsi sebelumnya. Mudah, cepat, fleksibel, dan memiliki banyak fitur canggih yang membantu desainer melihat dan memeriksa perilaku sinyal yang dipilih dengan cepat.

Ringkasan

Artikel ini berisi beberapa tangkapan layar dari GUI Vivado. Klik gambar untuk memperbesar!

Gunakan bilah sisi untuk menavigasi garis besar untuk tutorial ini, atau gulir ke bawah dan klik tombol navigasi pop-up di pojok kanan atas jika Anda menggunakan perangkat seluler.

ILA dan VIO

ILA dan VIO adalah IP gratis yang dapat disesuaikan dari Xilinx. IP ILA membantu Anda dengan mudah menyelidiki sinyal internal di dalam FPGA dan membawanya ke lingkungan seperti simulasi untuk memantau dan memverifikasi perilakunya.

Tidak seperti ILA, VIO IP memungkinkan Anda untuk menggerakkan sinyal internal secara virtual di dalam FPGA Anda untuk merangsang atau mengontrol desain Anda, seperti menggerakkan sinyal RESET.

Kekayaan Intelektual Xilinx:Penganalisis Logika Terintegrasi (ILA)
Kekayaan Intelektual Xilinx:Input/Output Virtual (VIO)

Persyaratan

Papan FPGA Xilinx
Suite Desain Vivado
Pengetahuan dasar VHDL

Saya menggunakan Kit Evaluasi Kintex-7 FPGA KC705, tetapi metode yang ditunjukkan dalam tutorial ini harus bekerja pada papan FPGA Xilinx modern.

Unduh proyek contoh

Anda dapat mengunduh contoh proyek dan kode VHDL menggunakan formulir di bawah ini. Ini harus bekerja di Vivado versi 2020.2 atau yang lebih baru.

Ekstrak Zip dan buka ila_tutorial.xpr file di Vivado untuk melihat contoh desain, atau baca sisa artikel ini untuk mempelajari cara membuatnya dari awal.

Buat proyek dengan Vivado

Mulailah dengan membuka Vivado. Di layar selamat datang Vivado, klik Buat Proyek tombol.

Klik Berikutnya untuk melanjutkan.

Ubah nama proyek menjadi ila_tutorial dan klik Berikutnya.

Catatan: Jangan gunakan spasi dalam nama proyek. Sebagai gantinya, gunakan garis bawah atau tanda hubung.

Pilih proyek RTL dan hapus centang Jangan tentukan sumber saat ini dan klik Berikutnya untuk melanjutkan.

Tambahkan file sumber; counter.vhdl dan counter_top.vhdl dari folder desain. Pilih VHDL untuk bahasa sasaran. Centang Salin sumber ke dalam proyek dan klik Berikutnya untuk melanjutkan.

Tambahkan file kendala top.xdc dari folder desain. Centang Salin file kendala ke dalam proyek dan klik Berikutnya untuk melanjutkan.

Catatan: file kendala ini khusus untuk papan KC705. Anda perlu mengubah pin clk dan pin led sesuai dengan papan Anda. Dan juga, -periode jam papan Anda.

Cari papan Anda dan pilih dari daftar. Klik Berikutnya untuk melanjutkan.

Ini adalah layar terakhir dari wizard Proyek Baru. Klik Selesai untuk membuka proyek Anda.

Penjelasan contoh desain

Kami akan menggunakan contoh rantai dua counter sederhana untuk tutorial ini.

counter.vhdl file berisi kode RTL untuk penghitung 4-bit sepele yang dihitung dari 0 hingga 15 saat diaktifkan. Ini menegaskan output 1-bit saat hitungan antara 12 dan 15. Untuk semua nilai lainnya, output tetap rendah '0' .

Berikut adalah antarmuka entitas untuk modul penghitung.

----------------------------------------------------------------------------
-- ENTITY DECLARATION.
----------------------------------------------------------------------------
  ENTITY counter IS
    PORT(clk     : IN  STD_LOGIC;  -- Main clock 
         reset   : IN  STD_LOGIC;  -- reset, active_high
         enable  : IN  STD_LOGIC;  -- enable the next counter
         trigger : OUT STD_LOGIC   -- trigger the next counter
        );
  END ENTITY;

Desain penghitung memiliki dua sinyal internal:hitung dan trigger_o .

– hitung digunakan untuk mengimplementasikan fungsi penghitungan.

– dan trigger_o adalah sinyal perantara untuk menghubungkan port keluaran pemicu .

Jangan khawatir tentang ATTRIBUT , nanti akan dijelaskan.

----------------------------------------------------------------------------
-- ARCHITECTURE DECLARATION.  
----------------------------------------------------------------------------
  ARCHITECTURE rtl OF counter IS

    -- INTERNAL SIGNALS DECLARATION --
    SIGNAL count     : UNSIGNED(3 DOWNTO 0) := (OTHERS => '0');
    SIGNAL trigger_o : STD_LOGIC := '0';
  
    -- ATTRIBUTE DECLARATION --  
    ATTRIBUTE MARK_DEBUG : STRING;
    ATTRIBUTE MARK_DEBUG OF count : SIGNAL IS "true";

Dalam daftar di bawah ini, kita melihat implementasi untuk penghitung. seq_proc proses dipicu pada tepi naik dari port input clk dan dalam mode reset ketika port input reset tinggi '1'.

hitungan sinyal bertambah ketika port input mengaktifkan tinggi '1', dan trigger_o sinyal dinyatakan tinggi ketika nilai sinyal hitung adalah antara 12 dan 15.

seq_proc: PROCESS (reset, clk)
BEGIN -- for seq_proc
  IF (reset = '1') THEN
    count     <= (OTHERS => '0');
    trigger_o <= '0';
  ELSIF rising_edge(clk) THEN
    IF (enable = '1') THEN
      count <= count + 1;
      IF (count > x"B" AND count <= x"F") THEN
        trigger_o <= '1';
      ELSE
        trigger_o <= '0';
      END IF;
    END IF;
  END IF;
END PROCESS;

File counter_top.vhdl berisi dua instan penghitung yang terhubung secara berurutan.

– counter_1_inst selalu diaktifkan, dan mencatat counter_2_inst . Artinya, port keluaran memicu dari counter_1_inst terhubung ke port input clk dari counter_2_inst .

– Perilaku yang dihasilkan adalah counter_1_inst mengaktifkan counter_2_inst hanya 4 dari 16 siklus clock. Jadi, counter_2_inst akan menambah penghitungnya empat kali setiap 16 hitungan.

Membuat inti VIO untuk RESET

Sekarang setelah Anda memahami contoh desain, kami akan membuat VIO untuk mengontrol port input reset . Itu akan memberi kita kemampuan untuk memanipulasi (mengalihkan) reset dari Vivado IDE sehingga kita dapat mengontrol secara manual kapan memulai/menghentikan penghitung.

Klik Katalog IP , lalu telusuri VIO , lalu klik dua kali pada VIO (Virtual Input/Output) .

Pertama, kita ganti namanya menjadi vio_reset .

Kedua, kita hanya membutuhkan port output untuk reset, jadi kita menempatkan 0 di kotak input probe count, dan kami meletakkan 1 di kotak jumlah probe keluaran .

Klik PROBE_OUT tab pelabuhan. Karena reset adalah sinyal 1-bit, kami meletakkan 1 di kotak probe_width, dan kami juga menempatkan 0x1 di kotak nilai awal jadi dimulai dengan tinggi '1'. Kemudian klik Oke dan Buat . Vivado sekarang akan mulai mensintesis VIO.

Setelah Vivado selesai mensintesis VIO, kita perlu menambahkannya ke desain kita dengan mendeklarasikan komponen untuknya dan membuat instance di counter_top.vhdl file seperti di bawah ini.

Pertama, tambahkan deklarasi komponen untuk vio_reset di bagian deklarasi komponen di counter_top.vhdl berkas.

  -- Declare vio_reset
  COMPONENT vio_reset
    PORT(
      clk        : IN STD_LOGIC;
      probe_out0 : OUT STD_LOGIC_VECTOR(0 DOWNTO 0)
    );
  END COMPONENT;

Sekarang, VIO selesai, dan kami siap untuk mensintesis desain. Namun sebelum itu, kita perlu mengubah pengaturan sintesis flatten_hierarchy menjadi Tidak ada .

Klik Jalankan Sintesis lalu pada Oke .

Saat Vivado menyelesaikan sintesis, klik Buka Desain Sintesis .

Ubah tata letak menjadi debug dengan mengeklik Tata Letak lalu Debug .

Memasukkan aliran probe debug

Desain sintesis kami sekarang berisi vio_reset instance, dan sekarang saatnya untuk menentukan sinyal yang ingin kita selidiki. Ada tiga cara untuk melakukannya:

Penyisipan dari file VHDL
Penyisipan dari Netlist
Penyisipan dari file xdc/tcl

Kami akan menggunakan dua metode pertama dan meninggalkan yang ketiga untuk tutorial selanjutnya.

Penyisipan dari file VHDL

Metode ini adalah cara termudah dan tercepat untuk memasukkan probe, terutama jika itu adalah tipe komposit (array atau record). Tapi itu membutuhkan penambahan kode ke file desain, kode VHDL yang berlebihan dalam produk nyata.

Kita dapat memasukkan probe ke dalam file desain VHDL dengan:

Mendeklarasikan atribut khusus yang disebut MARK_DEBUG
Lampirkan sinyal yang ingin kita selidiki dengan atribut ini
Dan aktifkan dengan memberikan nilai “true” seperti di bawah ini:

    -- ATTRIBUTE DECLARATION --  
    ATTRIBUTE MARK_DEBUG : STRING;
    ATTRIBUTE MARK_DEBUG OF count : SIGNAL IS "true";

Catatan: kita hanya perlu mendeklarasikan atribut sekali dalam setiap file desain VHDL, memungkinkan kita untuk melampirkannya ke beberapa sinyal.

Kita dapat melihat dari desain yang disintesis bahwa sinyal menghitung di kedua counter_1_inst dan counter_2_inst tercantum di bawah Jaring Debug yang Tidak Ditetapkan dan ditandai dengan ikon bug di kedua Netlist dan Skematis .

Penyisipan dari Netlist

Metode penyisipan ini juga mudah, tetapi Anda harus terlebih dahulu mensintesis desain dan kemudian secara manual mengklik setiap sinyal untuk menandainya untuk debugging. Ini bisa melelahkan jika desainnya besar dan Anda ingin memantau banyak sinyal.

Kami akan menyelidiki pemicu port keluaran di kedua penghitung menggunakan Netlist . Kita dapat melakukannya dari jendela Netlist atau Skematis dengan mencari jaring sinyal dan kemudian klik kanan di atasnya dan pilih Tandai Debug .

Dari jendela Netlist, temukan pemicu di bawah counter_1_inst → Jaring → pemicu . Kemudian, klik kanan padanya dan pilih Tandai Debug .

Dari jendela Skema, temukan pemicu keluaran dari counter_2_inst . Kemudian, klik kanan padanya dan pilih Tandai Debug .

Kita dapat melihat bahwa mereka sekarang terdaftar di bawah Jaring Debug yang Tidak Ditetapkan .

Membuat inti debug ILA

Sekarang saatnya membuat inti debug ILA. Kita perlu membuat probe untuk setiap sinyal yang ingin kita analisis. Cara termudah adalah dengan memanfaatkan wizard Vivado Siapkan Debug .

Klik Siapkan Debug lalu klik Berikutnya .

Vivado akan mencantumkan semua sinyal debug dan menangkap domain jam untuk Anda secara otomatis. Di sini kita melihat bahwa empat sinyal kita terdaftar. Anda dapat menghapus sinyal yang tidak Anda minati atau menambahkan sinyal tambahan, tetapi kami akan menggunakan semuanya.

Catatan: kami tidak harus menggunakan semua sinyal yang telah kami tandai sebagai Debug.

Klik Berikutnya .

Sekarang kita mengonfigurasi ILA dengan memilih kedalaman FIFO dan memeriksa Capture control . Kita dapat meninggalkan FIFO di 1024 karena itu cukup dalam untuk contoh kita.

Klik Berikutnya .

Sekarang kita melihat bahwa Vivado menemukan satu jam dan akan membuat satu inti debug.

Klik Selesai .

Sekarang kita dapat melihat inti debug ILA dengan empat probe yang ditambahkan ke tab debug dan jendela Netlist .

PENTING: Sangat penting untuk menyimpan kendala dalam tahap ini sehingga dapat ditambahkan ke desain. Jika tidak, kami berisiko kehilangan inti ILA kami.

Klik Simpan ikon atau tekan Ctrl+S.

Beri nama file ila_core dan klik Oke .

ila_core.xdc file akan ditambahkan ke kendala, dan itu termasuk kode dan pengaturan untuk ILA.

Mari kita lihat isi filenya. Anda dapat membuka file dengan membuka jendela Sumber → perluas folder kendala → perluas constr_1 .

Pertama, kita melihat bahwa file menambahkan atribut debug ke sinyal yang kita tandai sebagai debug menggunakan penyisipan Netlist.

Selanjutnya, kita melihat pembuatan dan konfigurasi inti ILA.

Selanjutnya, kita melihat pembuatan, konfigurasi, dan koneksi untuk setiap probe.

Selanjutnya, kita melihat pembuatan hub debug (dbg_hub ).

Hub debug bertanggung jawab atas komunikasi antara Vivado IDE dan inti debug (ILA dan VIO). Kami melihat bahwa ini mendefinisikan frekuensi clock (defaultnya adalah 300 MHz). Anda perlu mengubah jam tersebut agar sesuai dengan frekuensi jam Anda dan menyimpan file.

Catatan: jam yang terhubung ke ILA dan Debug_hub harus jam yang berjalan bebas.

Sekarang, ILA selesai dan disimpan. Kita perlu menjalankan kembali sintesis agar ILA dapat ditambahkan ke desain yang disintesis.

Klik Jalankan Sintesis lalu pada Oke .

Ketika Vivado selesai menjalankan sintesis, klik Buka Desain Sintesis lalu pada Skematis .

Kita dapat melihat sekarang bahwa Vivado telah menambahkan ILA dan Debug_Hub ke desain kita dan telah menghubungkan sinyal debug ke probe ILA.

Sekarang kami siap untuk mengimplementasikan desain kami dan menghasilkan bitstream sehingga kami dapat menguji desain kami.

Klik Jalankan Penerapan lalu pada Oke .

Setelah Vivado selesai menjalankan implementasi, klik Generate Bitstream lalu pada Oke .

Setelah Vivado selesai menghasilkan bitstream, klik Open Hardware Manager lalu pada Target Terbuka, dan terakhir di Sambung otomatis .

Selanjutnya, kita perlu memprogram FPGA dengan file bit (*.bit) dan file probe debug (*.ltx). Vivado secara otomatis menemukan mereka untuk Anda.

Klik Program Perangkat lalu di Program .

Mengonfigurasi pemicu ILA

Setelah memprogram perangkat, kita dapat melihat bahwa tata letak GUI Vivado telah berubah, dan hw_ila_1 baru dasbor telah terbuka, berisi beberapa jendela.

Kami akan meminimalkan beberapa jendela yang tidak kami butuhkan sehingga kami dapat bekerja dengan nyaman.

Dari opsi dasbor, centang hw_vio_1 dan hapus centang Capture Setup .

Juga, tutup hw_vios tab karena ketika kami memeriksa hw_vio_1 , telah ditambahkan ke Penyiapan pemicu jendela.

Sekarang, kita perlu menambahkan reset tombol ke VIO sehingga kami dapat mengontrol reset .

Klik hw_vio_1 lalu tambahkan setel ulang seperti yang ditunjukkan pada gambar di bawah ini.

Kita dapat melihat bahwa hw_vio_1 sekarang berisi reset penyelidikan.

Ubah nilai reset di vio_reset ke 1 jika bukan 1.

Sekarang, kita akan menambahkan trigger yang akan kita gunakan. Perubahan nilai pada sinyal pemicu akan menyebabkan ILA mulai merekam sinyal yang diperiksa.

Katakanlah kita ingin memicu (mulai merekam) di tepi naik dari port keluaran pemicu dari counter_1_inst . Untuk melakukannya, ikuti langkah-langkah berikut:

Buka Penyiapan Pemicu – hw_ila_1 jendela
Klik + ikon untuk menambahkan pemicu baru dan pilih counter_1_inst/trigger dan klik Oke.

Kita dapat melihat bahwa pemicu telah ditambahkan, dan sekarang kita perlu mengatur kondisinya. Klik pada kotak Nilai dan pilih R(transisi 0 ke 1) . Klik pada kotak Operator dan pilih ==(sama dengan)

Kami juga akan mengubah posisi pemicu menjadi 32, yang berarti akan merekam 32 sampel sebelum peristiwa pemicu selain yang terjadi setelahnya.

Sekarang, pelatuknya sudah disiapkan dan siap untuk dipersenjatai.

Sekarang, kita pindah ke jendela bentuk gelombang untuk menambahkan sinyal yang ingin kita lihat. Pertama, mari maksimalkan jendela bagian dalam untuk mendapatkan tampilan yang lebih baik.

Kedua, kita perlu menambahkan beberapa sinyal yang hilang ke probe. Vivado biasanya menambahkan semua sinyal yang ditetapkan secara otomatis, tetapi dalam kasus ini, tidak.

Sekarang, kita ubah radix dari hitungan sinyal ke Unsigned karena lebih mudah diikuti.

Klik kanan pada hitung nama sinyal lalu pilih radix lalu Tidak ditandatangani .

Menjalankan ILA dan VIO

Sekarang, kami telah selesai mengonfigurasi dan menyesuaikan ILA, dan kami siap untuk menjalankannya.

ILA memiliki dua mode berjalan:Segera dan pemicu .

Mode langsung

Mode segera memicu ILA segera dan mulai merekam sampel secara langsung hingga FIFO penuh.

Klik Jalankan pemicu segera tombol.

Kita sekarang dapat melihat sampel yang direkam di jendela bentuk gelombang. Kami melihat bahwa keduanya menghitung sinyalnya 0, dan keduanya memicu sinyal rendah '0' karena setel ulang aktif.

Mode pemicu

Mode pemicu mengharuskan kami menyiapkan kondisi untuk setidaknya satu pemicu dan mengaktifkannya. ILA akan terus menunggu hingga kondisi pemicu bersenjata menjadi kenyataan, dan kemudian akan mulai merekam sampel secara langsung hingga FIFO penuh.

Kami telah menambahkan pemicu dan menyetelnya ke R(transisi 0 ke 1) .

Menjalankan ILA dengan satu pemicu

Ubah setel ulang kembali ke 1 dari vio_reset .

Klik pada jendela Status hw_ila_1 . Kami melihat bahwa status inti adalah Idle karena tidak ada pemicu bersenjata. Klik Jalankan pemicu tombol, dan itu akan mempersenjatai pelatuk.

Kami melihat sekarang bahwa status inti berubah menjadi menunggu pemicu . Sebagai setel ulang tinggi, tidak ada aktivitas pada sinyal pemicu kami (port pemicu dari counter_1_inst ), dan ILA sedang menunggu.

Sekarang, mari kita ubah reset ke 0 sehingga penghitung mulai bekerja.

Kami melihat sekarang ILA telah dipicu dan telah merekam sampel, dan status inti berubah kembali ke Idle .

Kami melihat garis vertikal merah (penanda) di tepi naik dari sinyal pemicu kami (port pemicu dari counter_1_inst ), dan berada di posisi 32 . Kami juga dapat memverifikasi bahwa sinyal menghitung berperilaku dengan benar dan sinyal counter_1_inst/trigger tinggi untuk empat siklus clock antara 12 dan 15 (output tertunda oleh satu siklus clock).

Jika kami memperkecil sedikit, kami juga dapat memverifikasi perilaku hitungan dan memicu sinyal untuk counter_2_inst .

Menjalankan ILA dengan beberapa pemicu

Kita dapat menggunakan kombinasi pemicu untuk kondisi kompleks atau lanjutan. Untuk menangkap beberapa kerangka waktu yang terputus-putus dalam bentuk gelombang yang sama, kita dapat menggunakan beberapa pemicu yang diaktifkan berulang kali.

Misalnya, katakanlah kita ingin memicu ketika menghitung sinyal dari counter_1_inst sama dengan 9 (hitung ==9) dan ketika hitung sinyal dari counter_2_inst lebih besar dari 2 (hitungan> 2). Untuk melakukannya dan membagi FIFO menjadi empat jendela waktu, ikuti langkah-langkah berikut:

Ubah setel ulang kembali ke 1 dari vio_reset
Hapus probe pemicu sebelumnya:

Tambahkan keduanya hitung sinyal sebagai pemicu:

Konfigurasikan sinyal hitung untuk counter_1_inst ke (hitung ==9):

Konfigurasikan sinyal hitung untuk counter_2_inst ke (hitungan> 2):

Konfigurasikan jumlah jendela menjadi 4 dan kedalaman FIFO hingga 256, dan posisikan ke 32 .

Click on the Run trigger button, and that will arm the trigger. Notice that in the window Status hw_ila_1 , the capture status is now window 1 of 4 because we have four windows.

Change reset back to 0 from vio_reset .

Maximize the waveform window. We see now that we have four windows and a trigger associated with each window. Notice that these windows are independent and not continuous.

The ILA waits for the trigger event to happen, and when it does, the ILA uses the first window to record 256 samples. It then immediately waits for the next trigger until all the windows are full.

Running ILA with Auto re-trigger mode

ILA has a nice feature called Auto re-trigger that will automatically arm the trigger after it gets triggered. It is useful when monitoring events that occur seldom and you want to run a test overnight. Or you can use it when the trigger happens so often and fast that you cannot arm the trigger manually to capture the samples repeatedly.

Let us assume that the output port trigger of counter_2_inst gets asserted every 3 hours, and you want to record the data each time it happens. To use the Auto trigger, follow these steps:

Change reset back to 1 from vio_reset
Remove the previous trigger probe
Add trigger_2_OBUF signal as trigger:

Configure the trigger to the condition to equal (==) and falling edge F(1-to-0 transition)
Configure the number of windows to 1 and FIFO depth to 1024, and position to 32:

Click on Auto re-trigger button:

Finally, change reset back to 0 from vio_reset:

We can see now that the waveform window is getting refreshed and updated as the trigger happen. It is fast, but the behavior is noticeable.

Click on Stop trigger and toggle Auto re-trigger .

Running ILA with Capture mode

Another feature of ILA is the Capture mode . In some cases, you are not interested in recording all the data but rather capture a specific sample. Capture mode helps you filter out data and record only the samples you are interested in.

Let’s say we are only interested in sampling when the output port trigger of counter_1_inst is ‘1’ AND the output port trigger of counter_2_inst is ‘0’.

To use Capture mode to achieve this, follow these steps:

Change reset back to 1 from vio_reset
Remove the previous trigger probe
From the dashboard, Uncheck Trigger Setup and check Capture Setup . Notice that a Capture Setup window will appear. From the Settings – hw_ila_1 window, Change Capture mode to BASIC , the window to 1, the FIFO depth to 1024, and position to 1:

Add trigger_2_OBUF , and counter_1_inst/trigger from the Capture Setup window:

Configure counter_1_inst/trigger to the condition equal (==) and 1 (logical one) :

Configure trigger_2_OBUF to the condition equal (==) and 0 (logical zero) :

Change the Capture Condition to Global AND :

Click on the Run trigger button and then change reset to 0 from vio_reset :

As we can see from the image below, the waveform has only recorded data when counter_1_inst’s count signal is 13, 14, 15, or 0. Any other counts are filtered out because counter_1_inst/trigger is high on these counts only.

Conclusion

In this tutorial, we learned about ILA and VIO and different use-cases for them. ILA and VIO are excellent options for on-chip debugging. They are free, easy to use, flexible, scalable, and simple yet offer advanced features. The use of multiple triggers and Capture mode helps you achieve a complex debugging scheme.

Verifikasi formal dalam VHDL menggunakan PSL Cara membuat daftar string di VHDL

VHDL