Pagiging dalubhasa sa $display sa Verilog: Mga Epektibong Teknik sa Pag-debug at Kontrol ng Display

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Panimula: Ang Kahalagahan at Layunin ng “display” sa Verilog

Ano Kahulugan ng “display” sa Verilog?

Sa Verilog, ang $display ay isang system task na ginagamit bilang kasangkapan upang “akita” ang panloob na estado ng isang disenyo habang isinasagawa ang simulation. Katulad ng printf sa C, pinapayagan ka nitong maglabas ng mga signal, halaga ng variable, at mga string sa isang terminal o console—na may mahalagang papel sa debugging at functional verification.

Bakit Mahalaga ang $display para sa Pag-unlad ng Verilog?

• Pinahusay na kahusayan sa debugging : Sa mga komplikadong disenyo ng sirkito, kritikal ang pag‑visualize kung tama ang paggana ng mga panloob na signal. Sa pamamagitan ng $display, agad mong masusuri ang mga halaga ng mga signal na interesado ka habang tumatakbo ang simulation.
• Pagpapakita ng simulation : Kapag sinusubaybayan ang pag‑lipat ng mga halaga sa tiyak na mga sandali, maaaring hindi sapat ang mga waveform lamang. Ang mga display log ay nagbibigay ng maaasahang paraan upang ituro ang mga eksaktong sandaling iyon.
• Kapaki-pakinabang din para sa dokumentasyon : Kapag naglalahad ng layunin ng disenyo o mga patakaran ng operasyon sa ibang mga inhinyero, ang pag‑insert ng mga anotadong display log ay maaaring magpahusay ng pag‑unawa sa code.

Layunin at Estruktura ng Artikulong Ito

Sa artikulong ito, sistematikong ipapaliwanag namin ang mga sumusunod:

1. Pangunahing syntax at paggamit : Maingat na pagpapakilala sa pundamental na syntax at paggamit ng $display.
2. Paghahambing sa ibang system tasks : Ilalahad namin ang mga pagkakaiba sa pagitan ng mga display‑related na task tulad ng $write, $strobe, at $monitor.
   3.Format specifiers at mga advanced na teknik** : Ipapakilala ang paggamit ng mga format specifier gaya ng %d, %b, %h, %s, at mga espesyal na teknik sa pag‑display.
3. Mga praktikal na halimbawa ng paggamit : Ipapakita namin ang konkretong paggamit sa mga test bench at code na may mga halimbawa, na nagbibigay ng agad na magagamit na kaalaman.
4. Mga aplikasyon ng display‑control : Kasama sa mga halimbawa ang hardware output tulad ng LCD o kontrol ng monitor at pag‑display ng teksto/larawan.

Sa ganitong estruktura, parehong ang mga baguhan at intermediate na gumagamit ay maaaring maunawaan nang wasto ang $display sa Verilog at magamit ito sa praktika. Sa bawat susunod na seksyon, magpapatuloy kami nang malinaw gamit ang mga halimbawa at diagram hangga’t maaari.

2. Mga Batayan ng $display: Syntax, Mga Kaso ng Paggamit, at Mga Paalala

Pangunahing Syntax ng $display

Kapag gumagamit ng $display sa Verilog, ang pangunahing syntax ay ganito:

$display("string or format specifiers", signal1, signal2, ...);

• String portion : Isulat ang anumang teksto o mga format specifier (halimbawa: %d, %b, %h).
• Arguments : Ilahad ang mga pangalan ng signal o variable na ilalabas ayon sa kaukulang format.

Halimbawa: Pag‑display ng bilang ng clock at mga halaga ng signal

$display("Time=%0t : clk=%b, reset=%b", $time, clk, reset);

Sa halimbawang ito, inilalabas ang oras ng simulation at mga halaga ng mga signal na clock/reset.

Mga Kaso ng Paggamit ng $display

1. Pag‑unawa sa progreso ng simulation – Sa pamamagitan ng pag‑insert ng $display sa mga tiyak na punto ng iyong disenyo, maaari mong beripikahin kung aling bahagi ng code ang naabot na ng execution.
2. Beripikasyon ng halaga ng signal – Kahit na ang mga waveform viewer ay maaaring magpahirap sa intuitibong pag‑intindi ng mga conditional branch o state transition, ang pag‑labas ng teksto ay nagpapadali ng pag‑unawa.
3. Conditional na pag‑display ng mensahe – Sa pamamagitan ng pagsasama nito sa mga if statement, maaari kang mag‑log ng mga mensahe lamang kapag natugunan ang tiyak na kondisyon. if (reset)("Reset asserted at %0t", $time);

Pagkakaiba ng $display at $write

Awtomatikong nagdadagdag ng newline ang $display sa dulo ng output. Samantalang ang $write ay nagpapatuloy ng output nang hindi nagdadagdag ng newline.

Halimbawa:

$display("Hello");
$display("World");

Output:

Hello
World

$write("Hello");
$write("World");

Output:

HelloWorld

Kung kailangan mo ng malinaw na line‑by‑line na log, gamitin ang $display. Kapag nais mo namang mag‑format ng mga output sa iisang linya, gamitin ang $write.

Mga Pagsasaalang‑alang

1. Iwasan ang labis na output
   Kung gagamit ka ng $display sa bawat clock cycle, lalaki nang malaki ang mga log at bababa ang nababasa. → Gumamit ng kondisyon upang bawasan ang output.

2.Gamitin ang time display**
Ang pag-output ng $time o $realtime ay nagbibigay-daan upang eksaktong ma‑capture ang timing ng mga operasyon.

3. Task na para lamang sa simulation
   Hindi maaaring gamitin ang $display para sa synthesis (FPGA/ASIC implementation). Ito ay striktong simulation‑only na tool para sa debugging.

3. Paghahambing ng Log Output System Tasks: $display, $write, $strobe, $monitor

Nag-aalok ang Verilog ng mga system task bukod sa $display para sa output. Ang kanilang magkaibang gamit at timing ay mahalagang maunawaan upang magamit nang tama ang bawat isa.

$display: Standard Display Task

• Katangian Awtomatikong nagdadagdag ng newline at nagla‑log ng isang linya bawat tawag.
• Gamit Kadalasang ginagamit bilang pangunahing debug method; maaari mo itong tawagin anumang oras para sa isang beses na output.

$write: Display Nang Walang Newline

• Katangian Hindi nagdadagdag ng newline kaya nagpapatuloy ang output sa parehong linya.
• Gamit Kapaki-pakinabang kapag nais mong ipakita ang maraming halaga nang magkatabi.
• Halimbawa $write("A=%d, ", a); $write("B=%dn", b); → Output: A=5, B=10.

$strobe: Output sa Dulo ng Simulation Cycle

• Katangian Nagpi‑print ng mga halaga pagkatapos makumpleto ang lahat ng simulation evaluation sa kasalukuyang hakbang.
• Gamit Kapaki-pakinabang upang maiwasan ang race conditions (kapag sabay‑sabay na nagbabago ang maraming signal).
• Halimbawa $robe("Time=%0t, signal=%b", $time, sig); → Habang maaaring magpakita ang $display ng intermediate values, ang $strobe ay nagpapakita ng settled values.

$monitor: Automatic Tracking Output

• Katangian Awtomatikong nag-ooutput kapag anumang monitored signal ay nagbago.
• Gamit Maginhawa kapag nais mong subaybayan ang isang hanay ng mga signal nang tuloy‑tuloy.
• Halimbawa $monitor("At %0t: a=%b, b=%b", $time, a, b); → Nagla‑log kapag nagbago man ang a o b.

Summary Table

Mga Tip para sa Epektibong Paggamit

• Gamitin ang $display bilang default : Madaling basahin at angkop para sa mga baguhan.
• Gamitin ang $write kapag nais mo ng isang linya na pinagsamang output .
• Gamitin ang $strobe kapag kailangan mo ng settled values pagkatapos ng mga pagbabago .
• Gamitin ang $monitor kapag kailangan mo ng tuloy‑tuloy na pag‑monitor ng signal .

4. Format Specifiers at Advanced Display Techniques

Sa mga task tulad ng $display o $write, maaari kang mag‑include ng “format specifiers” sa mga string upang i‑output ang mga signal o variable sa nais na format. Dahil kahawig ito ng printf ng C, ang tamang paggamit nito ayon sa layunin ay lubos na nagpapahusay sa kahusayan ng debugging.

Basic Format Specifiers

Praktikal na Halimbawa

1. I‑display ang isang signal sa maraming format
   reg [7:0] data = 8'b10101010; $display("data = %b (bin), %d (dec), %h (hex)", data, data, data); → Halimbawa ng output: data = 10101010 (bin), 170 (dec), AA (hex)

2. Suriin ang module hierarchy
   $display("Current module hierarchy is %m"); → Halimbawa ng output: Current module hierarchy is top.u1.counter

3. ‑display ang simulation time
   $display("Time=%0t: clk=%b", $time, clk); → Halimbawa ng output: Time=100: clk=1

Advanced Display Techniques

• Zero-padding at lapad ng field Maaari kang magtakda ng zero-padding o lapad ng field tulad ng %0d. Halimbawa: $display("Count=%04d", count); → Output: Count=0012
• Pagkakaiba ng signed at unsigned %d tinatrato ang mga halaga bilang signed, %u bilang unsigned. Kung ang negatibong halaga ay hindi lumalabas ayon sa inaasahan, baguhin ang specifier.
• Pag-format ng multi-line na mensahe Gamitin ang n upang hatiin ang mga linya para sa madaling basahin. Halimbawa: $display("Start of testnSignal A=%bnSignal B=%b", A, B);

Mga Paalala

• Isaalang-alang ang bit-width : Maaaring magkakaiba ang lapad ng mga Verilog signal; ang paggamit ng %d ay maaaring magdulot ng truncation o sign‑extension na problema.
• Paghawak sa hindi tinukoy na mga halaga (X, Z) : Kung isasama mo ang mga hindi tinukoy na bits, ang paggamit ng %b ay magpapakita ng x o z nang direkta.

5. Praktikal na Halimbawa: Paggamit ng $display sa Test Benches at Modules

Mula dito ay ipapakita namin ang epektibong paggamit ng $display sa pamamagitan ng totoong mga halimbawa ng Verilog code, saklaw ang mga batayan ng test benches hanggang sa conditional debug logging.

Pangunahing Halimbawa: Output sa isang Test Bench

Sa pamamagitan ng paglalagay ng $display sa isang test bench, maaari mong obserbahan ang pag-uugali habang nagsasagawa ng simulation.

module tb_counter;
  reg clk;
  reg reset;
  wire [3:0] count;

  // DUT (Device Under Test)
  counter uut (
    .clk(clk),
    .reset(reset),
    .count(count)
  );

  // Clock generation
  initial begin
    clk = 0;
    forever #5 clk = ~clk;  // invert every 5 units
  end

  // Test scenario
  initial begin
    reset = 1;
    #10 reset = 0;

    #50 $finish;
  end

  // Display state
  always @(posedge clk) begin
    $display("Time=%0t | reset=%b | count=%d", $time, reset, count);
  end
endmodule

Sa halimbawang ito, bawat pagtaas ng clock ay nagti‑trigger ng output ng reset at count. Dahil maaari mong tingnan ang mga text log pati na rin ang mga waveform, mas nagiging madali ang pagsubaybay sa pag-uugali.

Halimbawa ng Conditional Display

Sa pamamagitan ng pagsasama ng mga if statement, maaari kang mag‑log lamang kapag natugunan ang tiyak na mga kondisyon.

always @(posedge clk) begin
  if (count == 4'd10) begin
    $display("Count has reached 10 (Time=%0t)", $time);
  end
end

→ Pinapayagan ka nitong iwasan ang labis na mga log habang tinutukoy ang mga pangyayaring mahalaga sa iyo.

Halimbawa ng Debug-Message

Sa panahon ng pag‑debug ng disenyo, epektibo itong mahuli kapag ang isang signal ay pumasok sa isang “hindi inaasahang estado”.

always @(posedge clk) begin
  if (count > 4'd12) begin
    $display("WARNING: count overflow detected! Time=%0t, value=%d", $time, count);
  end
end

→ Maaari mong mabilis na matuklasan ang mga depekto sa disenyo o hindi inaasahang pag‑ugali ng simulation.

Pagsubaybay sa Maramihang Signal nang Sabay

Kapag nag‑output ng maraming signal, ang pagsasama‑sama ng mga ito sa isang linya gamit ang $display ay nagpapadali sa pagbabasa ng mga log.

$display("Time=%0t | clk=%b | reset=%b | A=%h | B=%h | SUM=%h",
         $time, clk, reset, A, B, SUM);

Buod ng Praktikal na Mga Tip

• Ilagay ang $display sa test bench upang makita ang progreso
• Gamitin ang mga conditional branch upang pinuhin ang mga log
• Lumikha ng mga warning message upang matuklasan ang mga anomaly
• Pagsamahin ang maramihang signal sa isang linya upang mapabuti ang nababasa

6. Mga Aplikasyon ng Display‑Control (Pixel/Teksto/Larawan na Display)

Hanggang ngayon, ipinakilala namin ang $display para sa mga simulation log. Gayunpaman, ang Verilog ay malawak ding ginagamit para sa “display control” sa mga hardware implementation (LCD, VGA, HDMI output). Sa seksyong ito, maikling tatalakayin natin kung paano magpatupad ng screen display sa antas ng hardware.

Pangunahing Konsepto ng Display Control

Upang magpakita ng teksto o larawan sa isang screen, kailangan mong lumikha ng mga video signal sa halip na simpleng gamitin ang $display.
Kadalasang mga control signal ay kinabibilangan ng:

• HSYNC (Horizontal Sync) : Signal na nagtatakda ng katapusan ng bawat linya
• VSYNC (Vertical Sync) : Signal na nagtatakda ng katapusan ng bawat frame
• RGB Data : Signal na kumakatawan sa kulay ng bawat pixel (hal., 8bit × 3 = 24bit na kulay)

Sa Verilog, kinokontrol mo ang mga signal na ito gamit ang mga counter at state machine at inilalabas ang mga ito batay sa timing upang maisakatuparan ang “screen display”.

Example 1: Displaying Color Bars

Ang pinaka-pangunahing halimbawa ay ang paglabas ng mga kulay na bar nang pahalang sa isang display.

always @(posedge clk) begin
  if (h_counter < 100)       rgb <= 24'hFF0000; // red
  else if (h_counter < 200)  rgb <= 24'h00FF00; // green
  else if (h_counter < 300)  rgb <= 24'h0000FF; // blue
  else                       rgb <= 24'h000000; // black
end

→ Ito ay nagreresulta sa pulang, berde, at asul na mga bar ng kulay na nakaayos sa buong screen nang pahalang.

Halimbawa 2: Pagpapakita ng Teksto

Para sa pagpapakita ng teksto, naghahanda ka ng font ROM at kino-convert ang pattern ng tuldok ng bawat karakter sa mga pixel.

// Referencing the pattern of 'A' from the font ROM and displaying
if (font_rom[char_code][y][x] == 1'b1)
    rgb <= 24'hFFFFFF;  // white for display
else
    rgb <= 24'h000000;  // black background

→ Ito ay nagdodrowing ng isang partikular na karakter (hal., “A”) sa screen.

Halimbawa 3: Pagpapakita ng Imahe

Upang magpakita ng imahe, binabasa mo ang naka-imbak na bitmap data (ROM o external memory) at kino-convert ito sa output na pixel.

rgb <= image_rom[addr];  // Retrieve color data from ROM

Sa mga embedded system na gumagamit ng FPGA, pinapayagan ka ng pamamaraang ito na magpakita ng simpleng mga icon o logo.

Pagkakaiba Kumpara sa Debug na $display

• $display ay text output (para lamang sa simulation)
• Ang kontrol ng display ay pagbuo ng video signal (maaaring i-implementa sa hardware)

Bagaman magkaiba ang kanilang layunin, madalas na nalilito ng mga nag-aaral ng Verilog ang dalawa.

• “Gusto kong i-verify ang pag-uugali habang nag-simulation” → Gin ang $display
• “Gusto kong maglabas sa aktwal na screen sa FPGA” → Disenyuhin ang video-signal logic

Pagpapalawak ng mga Aplikasyon

• Sa pag-aaral ng mga FPGA board, madalas gamitin ang Verilog para sa 7-segment LED display o maliit na LCD display.
• Sa pag-usad, maaari kang bumuo ng mga sistema na sumusuporta sa VGA/HDMI output para sa pag-develop ng laro o pagpapakita ng GUI.
• Sa pamamagitan ng pagsasama ng kaalaman sa $display at display-control logic, maaari mong pamahalaan ang “display” kapwa sa simulation at sa aktwal na hardware.

7. Angkop na Paggamit at Mga Tip Batay sa Mga Senaryo ng Aplikasyon

Kapag pinag-uusapan natin ang “display” sa Verilog, may dalawang aspeto: ang simulation-only $display tasks, at ang hardware implementation display control. Ang tamang paggamit ng bawat isa ay nagdudulot ng epektibong pag-develop at debugging.

Paggamit sa Simulation

1. $display bilang debug log
   • I-output ang mga kritikal na variable o signal gamit ang $display upang suriin kung ang iyong disenyo ay gumagana ayon sa inaasahan.
   • Ang pag-verify ng “mga halaga sa ilalim ng tiyak na kondisyon” o “pag-abot ng counter sa mga punto” sa pamamagitan ng mga log ay epektibo.
2. Iwasan ang labis na output
   • Ang pag-output bawat clock cycle ay nagbubaha ng mga log at nagpapababa ng nababasa. Paliitin ang mga kondisyon.
   • Halimbawa: if (state == ERROR) $display("Error occured at %0t", $time);
3. Pag-iba-iba ng mga gawain
   • $monitor → Para sa mga signal na nais mong bantayan nang tuloy-tuloy
   • $strobe → Kapag kailangan mong i-output ang mga settled na halaga
   • $write → Para sa formatted na pahalang na output

Paggamit sa Hardware Display Control

1. 7-segment display para sa pag-aaral
   • Sa mga proyektong FPGA para sa mga baguhan, ang pagpapakita ng halaga ng counter sa 7-segment LED ay karaniwan.
   • Pagsamahin ito sa $display simulation output upang mapalalim ang pag-unawa sa pagkakaiba ng display at simulation.
2. Kontrol ng LCD o VGA monitor
   • Gamitin ang font ROM o image ROM upang magpakita ng teksto o imahe.
   • Sa pamamagitan din ng paggamit ng $display sa simulation, maaari mong doblehin ang pag-verify na tama ang pagbuo ng video-signal.
3. Debug overlay sa hardware
   • Maaari mong i-overlay ang “counter value”, “coordinates”, “debug messages” sa aktwal na video output.
   • Sa pag-develop ng FPGA, karaniwan na “gawing debugging tool mismo ang screen”.

Praktikal na Mga Tip

• Sundin ang simulation → hardware flow Una, gamitin ang $display upang beripikahin ang pag-uugali sa simulation, pagkatapos ay lumipat sa display-control logic para sa hardware implementation.
• Gamitin ang mga log at waveform nang sabay Ang mga text log mula sa $display ay nagpapahiwatig ng “timing ng paglitaw ng pangyayari”, habang ang mga waveform ay nagpapakita ng “detalyadong paglipat”. Ang paggamit ng pareho ay nagpapataas ng katumpakan ng debugging.
• Pagsamahin ang format ng mensahe sa pag-unlad ng koponan Ang pag-standardize ng format ng mensahe ng $display (prefix,akita ng oras, atbp.) ay nagpapadali ng pagsusuri ng log kapag maraming tao ang nagtatrabaho nang sabay.

Buod

• Ang mga gawain ng uri $display ay “observation tools” na para lamang sa simulation.
• Ang display control ay nangangahulugang hardware implementation “display method”.
• Sa pamamagitan ng tamang paggamit ng bawat isa at pagsasama nito, maaari kang magpatupad epektibong pag-unlad.

8. FAQ (Mga Madalas Itanong)

Q1. Ano ang pagkakaiba ng $display at $monitor?

A. Ang $display ay naglalabas ng isang beses sa sandaling ito ay tinawag. Sa kabilang banda, ang $monitor ay awtomatikong nagabas tuwing may pagbabago sa isang rehistradong signal.

• Para sa isang beses na debugging → $display
• Para sa patuloy na pagmamanman → $monitor

Q2. Kailan dapat gamitin ang $strobe?

A. Ang $strobe ay naglalabas ng settled value sa dulo ng isang simulation cycle. Halimbawa, kapag maraming signal ang nagbago nang sabay sa isang clock edge, maaaring magpakita ang $display ng intermediate values. Sa mga ganitong kaso, maginh ang $strobe para ipakita ang mga huling halaga.

Q3. Ano ang gamit ng format specifier na %m?

A. Ang %m ay naglalabas ng kasaluk pangalan ng module hierarchy. Sa malalaking disenyo, ang pag-log ng “kung aling hierarchy nagmula ang mensahe” ay nagpapadali nang malaki sa pagsusuri.

$display("Current module: %m");

Example output:

Current module: top.u1.counter

Q4. Ang mga log ko ay naging napakalaki dahil gumamit ako ng maraming $display. Ano ang dapat gawin?

A. Ang mga sumusunod na hakbang ay epektibo:

• Gumamit ng if statements upang i-filter ang output
• Mag-output lamang ng error detection o tiyak na mga pangyayari
• Gamitin ang $monitor upang subaybayan lamang ang pinakamababang kinakailangang mga signal
• I-output sa isang log file at mag-apply ng mga filtering tool sa panahon ng pagsusuri

Q5. Maaari bang gamitin ang $display para sa synthesis (FPGA/ASIC)?

A. Hindi. Ang $display ay striktong simulation-only task. Hindi ito kinikilala ng synthesis tools kaya hindi ito lumalabas sa aktwal na hardware. Kung nais mong mag-display ng output sa totoong hardware, kailangan mong magdisenyo gamit ang “7-segment LED”, “LCD”, “VGA control logic”, atbp., sa Verilog.

Q6. Paano ko maipapakita ang teksto o mga imahe sa aktwal na hardware?

A. Hindi sa pamamagitan ng $display, kundi sa pagbuo ng video signals.

• 7-segment display → Para sa simpleng numeric o character display
• VGA/LCD → Bumuo ng HSYNC, VSYNC, RGB signals at kontrolin ang mga ito
• Teksto → Gumamit ng font ROM at mag-output ng dot patterns
• Imahe → Mag-imbak ng mga bitmap sa ROM o external memory at mag-output ng mga pixel naaayon

9. Konklusyon at Mga Susunod na Hakbang

Buod ng Artik Ito

Sa artikulong ito tinalakay namin ang “display” sa Verilog mula sa mga batayan hanggang sa mga aplikasyon. Kabilang sa mga pangunahing punto ang:

1. Mga Batayan ng $display
   • Isang simulation task na nagdi-display ng mga signal o variable, magagamit katulad ngprintf` ng C.
2. Pagkakaiba sa mga kaugnay na gawain
   • $write → Display nang walang newline
   • $strobe → Naglalabas ng settled values sa dulo ng simulation cycle
   • $monitor → Awtomatikong nagmomonitor ng pagbabago ng signal
3. Paggamit ng mga format specifier
   • Sa pamamagitan ng paggamit ng %b, %d, %h, %m, %t, maaari kang mag-output ng mas malinaw at praktikal na mga log.
4. Mga praktikal na halimbawa
   • Ipasok ang $display sa test benches upang subaybayan ang progreso.
   • Gumamit ng conditional na mga mensahe upang mapadali ang epektibong debugging.
5. Mga aplikasyon sa display control
   • Ang $display ay para lamang sa simulation; ang hardware implementation ay gumagamit ng HSYNC, VSYNC, RGB upang mag-output ng teksto/imahe.
   • Mula sa pag-aaral ng 7-segment display hanggang sa advanced na VGA/HDMI control, maraming posibilidad ang maaaring tuklasin.

Mga Susunod na Hakbang

• Advance to SystemVerilog → Sa susunod na wika na SystemVerilog maaari kang gumamit ng mas advanced na mga tampok sa pag-debug (assertions, pinahusay na $display, atbp.).
• Combine with waveform viewer → Sa pamamagitan ng pagsasama ng mga log ng $display at waveform data, maaari mong suriin ang parehong numerong halaga at mga transisyon, na nagpapataas ng katumpakan ng pag-debug.
• Learn hardware display output → Sa isang maliit na proyektong FPGA board, subukang mag-output sa 7-segment o LCD upang maranasan ang pagkakaiba sa pagitan ng “simulation display” at “hardware display control”.
• Apply in team development → Sa pamamagitan ng pag-standardize ng format ng mensahe ng $display, pinapabuti mo ang kahusayan ng pagsusuri ng log sa multi-person development.

Sa Pagtatapos

$display ay higit pa sa simpleng “text output”. Ito ay isang makapangyarihang kasangkapan para sa simulation debugging. At kapag pumasok ka sa mundo ng display control, maaari mong maranasan ang kasiyahan ng pagpapakita ng graphics sa tunay na monitor gamit ang FPGA.
Sana ay nakatulong ang artikulong ito sa mga nag-aaral ng Verilog na maunawaan nang malinaw ang parehong “simulation debugging” at “hardware display output”.