Verilog में $display को मास्टर करना: प्रभावी डिबगिंग और डिस्प्ले नियंत्रण तकनीकें

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

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

1. परिचय: Verilog में “display” का महत्व और उद्देश्य

Verilog में “display” का क्या अर्थ है?

Verilog में, $display एक सिस्टम टास्क है जिसका उपयोग सिमुलेशन के दौरान डिज़ाइन की आंतरिक स्थिति को “display” करने के लिए किया जाता है। C के printf के समान, यह आपको सिग्नल, वेरिएबल मान, और स्ट्रिंग्स को टर्मिनल या कंसोल पर आउटपुट करने देता है—डिबगिंग और फ़ंक्शनल वेरिफिकेशन में केंद्रीय भूमिका निभाता है।

Verilog विकास में $display क्यों आवश्यक है?

• डिबगिंग दक्षता में सुधार : जटिल सर्किट डिज़ाइनों में, आंतरिक सिग्नल सही ढंग से काम कर रहे हैं या नहीं, इसे विज़ुअलाइज़ करना अत्यंत महत्वपूर्ण है। $display का उपयोग करके आप सिमुलेशन के दौरान रुचि के सिग्नल के मान तुरंत जांच सकते हैं।
• सिमुलेशन विज़ुअलाइज़ेशन : विशिष्ट समय बिंदुओं पर मान परिवर्तन को ट्रैक करते समय, केवल वेवफ़ॉर्म पर्याप्त नहीं हो सकते। डिस्प्ले लॉग्स उन सटीक क्षणों को इंगित करने का विश्वसनीय साधन प्रदान करते हैं।
• दस्तावेज़ीकरण के लिए भी उपयोगी : डिज़ाइन इरादा या ऑपरेशनल नियमों को अन्य इंजीनियरों तक पहुँचाते समय, एनोटेटेड डिस्प्ले लॉग्स डालने से कोड की समझ बढ़ती है।

इस लेख का उद्देश्य और संरचना

इस लेख में हम क्रमबद्ध रूप से निम्नलिखित बिंदुओं को समझाएंगे:

1. बेसिक सिंटैक्स और उपयोग : $display के मूल सिंटैक्स और उपयोग का सावधानीपूर्वक परिचय।
2. अन्य सिस्टम टास्क्स के साथ तुलना : $write, $strobe, और $monitor जैसे डिस्प्ले‑संबंधित टास्क्स के बीच अंतर को व्यवस्थित करेंगे।
3. फ़ॉर्मेट स्पेसिफ़ायर्स और उन्नत उपयोग तकनीकें : %d, %b, %h, %s जैसे फ़ॉर्मेट स्पेसिफ़ायर्स और विशेष डिस्प्ले तकनीकों का परिचय।
4. व्यावहारिक उपयोग उदाहरण : टेस्ट‑बेंच और कोड में ठोस उदाहरण दिखाएंगे, जिससे तुरंत लागू करने योग्य नॉलेज मिल सके।
5. डिस्प्ले‑कंट्रोल एप्लिकेशन : LCD या मॉनिटर कंट्रोल जैसे हार्डवेयर आउटपुट और टेक्स्ट/इमेज आउटपुट के उदाहरण उपयोग केस शामिल करेंगे।

इस संरचना के साथ, शुरुआती और मध्यवर्ती दोनों उपयोगकर्ता Verilog में $display को सही ढंग से समझ सकते हैं और व्यावहारिक रूप से लागू कर सकते हैं। आगे के प्रत्येक सेक्शन में हम स्पष्ट उदाहरण और जहाँ संभव हो डायग्राम का उपयोग करेंगे।

2. $display की बुनियादें: सिंटैक्स, उपयोग‑केस, और सावधानियाँ

$display का बेसिक सिंटैक्स

Verilog में $display का उपयोग करते समय बेसिक सिंटैक्स इस प्रकार है।

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

• स्ट्रिंग भाग : कोई भी टेक्स्ट या फ़ॉर्मेट स्पेसिफ़ायर लिखें (उदाहरण: %d, %b, %h)।
• आर्ग्युमेंट्स : संबंधित फ़ॉर्मेट में आउटपुट करने के लिए सिग्नल नाम या वेरिएबल सूचीबद्ध करें।

उदाहरण: क्लॉक काउंट और सिग्नल मान प्रदर्शित करना

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

इस उदाहरण में सिमुलेशन समय और क्लॉक/रीसेट सिग्नल के मान आउटपुट होते हैं।

$display के उपयोग‑केस

1. सिमुलेशन प्रगति को समझना : डिज़ाइन के विशिष्ट बिंदुओं पर $display डालकर आप यह सत्यापित कर सकते हैं कि कोड का कौन‑सा भाग निष्पादित हुआ है।
2. सिग्नल मान सत्यापन : जब वेवफ़ॉर्म व्यूअर से कंडीशनल ब्रांच या स्टेट ट्रांज़िशन को सहजता से समझना कठिन हो, तो टेक्स्ट आउटपुट से समझ आसान हो जाती है।
3. शर्तीय संदेश प्रदर्शित करना : if स्टेटमेंट के साथ मिलाकर आप केवल विशिष्ट शर्तों के पूरा होने पर ही लॉग संदेश लिख सकते हैं। if (reset) $display("Reset asserted at %0t", $time);

$display और $write में अंतर

$display आउटपुट के अंत में स्वचालित रूप से एक नई पंक्ति (newline) जोड़ता है। दूसरी ओर, $write नई पंक्ति नहीं जोड़ता और आउटपुट को लगातार लिखता रहता है।
उदाहरण:

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

आउटपुट:

Hello
World

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

आउटपुट:

HelloWorld

यदि आपको लाइन‑बाय‑लाइन स्पष्ट लॉग चाहिए तो $display उपयोग करें। जब आप एक ही पंक्ति में कई आउटपुट फॉर्मेट करना चाहते हैं तो $write उपयोग करें।

सावधानियाँ

1. अत्यधिक आउटपुट से बचें यदि आप हर क्लॉक साइकिल में $display का उपयोग करते हैं, तो लॉग बहुत बड़े हो जाते हैं और पढ़ने में कठिनाई होती है। → आउटपुट को कम करने के लिए कंडीशनिंग का उपयोग करें।
2. समय प्रदर्शन का उपयोग करें $time या $realtime आउटपुट करने से आप ऑपरेशनों के टाइमिंग को सटीक रूप से कैप्चर कर सकते हैं।
3. केवल सिमुलेशन के लिए डिज़ाइन टास्क $display को सिंथेसिस (FPGA/ASIC इम्प्लीमेंटेशन) में उपयोग नहीं किया जा सकता। यह केवल सिमुलेशन‑केवल डिबग टूल है।

3. लॉग आउटपुट सिस्टम टास्क की तुलना: $display, $write, $strobe, $monitor

Verilog $display के अलावा आउटपुट के लिए सिस्टम टास्क प्रदान करता है। इनके विभिन्न उपयोग‑केस और टाइमिंग को समझना प्रभावी उपयोग के लिए आवश्यक है।

$display: स्टैंडर्ड डिस्प्ले टास्क

• विशेषताएँ स्वचालित रूप से नई लाइन जोड़ता है और प्रत्येक कॉल पर एक लाइन लॉग करता है।
• उपयोग‑केस सबसे आम बुनियादी डिबग विधि; आप इसे किसी भी समय एक‑बार आउटपुट के लिए कॉल कर सकते हैं।

$write: नई लाइन के बिना डिस्प्ले

• विशेषताएँ नई लाइन नहीं जोड़ता, इसलिए आउटपुट उसी लाइन पर जारी रहता है।
• उपयोग‑केस जब आप कई मानों को साइड‑बाय‑साइड दिखाना चाहते हैं।
• उदाहरण $write("A=%d, ", a); $write("B=%dn", b); → आउटपुट: A=5, B=10 ।

$strobe: सिमुलेशन साइकिल के अंत में आउटपुट

• विशेषताएँ वर्तमान स्टेप में सभी सिमुलेशन इवैल्यूएशन समाप्त होने के बाद मान प्रिंट करता है।
• उपयोग‑केस रेस कंडीशन से बचने के लिए उपयोगी (जब कई सिग्नल एक साथ बदलते हैं)।
• उदाहरण $strobe("Time=%0t, signal=%b", $time, sig); → जबकि $display मध्यवर्ती मान दिखा सकता है, $strobe स्थिर (settled) मान दिखाता है।

$monitor: ऑटोमैटिक ट्रैकिंग आउटपुट

• विशेषताएँ जब भी कोई मॉनिटर किया गया सिग्नल बदलता है, स्वचालित रूप से आउटपुट देता है।
• उपयोग‑केस जब आप लगातार कई सिग्नलों की निगरानी करना चाहते हैं।
• उदाहरण $monitor("At %0t: a=%b, b=%b", $time, a, b); → a या b में से किसी एक के बदलने पर लॉग करता है।

सारांश तालिका

प्रभावी उपयोग के टिप्स

• डिफ़ॉल्ट रूप से $display का उपयोग करें : पढ़ने में आसान और शुरुआती के लिए उपयुक्त।
• जब आप एक ही लाइन में संयुक्त आउटपुट चाहते हैं तो $write उपयोग करें।
• परिवर्तनों के बाद स्थिर मान चाहिए तो $strobe उपयोग करें।
• लगातार सिग्नल मॉनिटरिंग चाहिए तो $monitor उपयोग करें।

4. फ़ॉर्मेट स्पेसिफ़ायर और उन्नत डिस्प्ले तकनीकें

$display या $write जैसे टास्क के साथ आप स्ट्रिंग में “फ़ॉर्मेट स्पेसिफ़ायर” शामिल कर सकते हैं ताकि सिग्नल या वेरिएबल को इच्छित फ़ॉर्मेट में आउटपुट किया जा सके। चूँकि यह C के printf जैसा है, इन्हें सही ढंग से उपयोग करने से डिबगिंग की दक्षता काफी बढ़ती है।

बुनियादी फ़ॉर्मेट स्पेसिफ़ायर

व्यावहारिक उदाहरण

1. सिग्नल को कई फ़ॉर्मेट में डिस्प्ले करें
   reg [7:0] data = 8'b10101010; $display("data = %b (bin), %d (dec), %h (hex)", data, data, data); → उदाहरण आउटपुट: data = 10101010 (bin), 170 (dec), AA (hex)
2. मॉड्यूल हायरार्की जांचें
   $display("Current module hierarchy is %m"); → उदाहरण आउटपुट: Current module hierarchy is top.u1.counter
3. सिमुलेशन टाइम डिस्प्ले करें
   $display("Time=%0t: clk=%b", $time, clk); → उदाहरण आउटपुट: Time=100: clk=1

उन्नत डिस्प्ले तकनीकें

• Zero-padding & field width आप शून्य‑भरण या फ़ील्ड चौड़ाई निर्दिष्ट कर सकते हैं जैसे %0d। उदाहरण: $display("Count=%04d", count); → आउटपुट: Count=0012
• Signed vs unsigned distinction %d मानों को साइन‑ड (signed) मानता है, जबकि %u उन्हें अनसाइन (unsigned) मानता है। यदि कोई नकारात्मक मान अपेक्षित रूप से नहीं दिख रहा है, तो स्पेसिफ़ायर को बदलें।
• Multi-line messages formatting पठनीयता के लिए लाइनों को तोड़ने हेतु \n का उपयोग करें। उदाहरण: $display("Start of test\nSignal A=%b\nSignal B=%b", A, B);

सावधानियां

• बिट‑चौड़ाई का ध्यान रखें : Verilog सिग्नल की चौड़ाई अलग‑अलग हो सकती है; %d का उपयोग करने से ट्रंकेशन या साइन‑एक्सटेंशन की समस्या हो सकती है।
• अपरिभाषित मान (X, Z) को संभालना : यदि आप अपरिभाषित बिट्स शामिल करते हैं, तो %b का उपयोग करने पर x या z सीधे प्रदर्शित होंगे।

5. व्यावहारिक उदाहरण: टेस्ट बेंच और मॉड्यूल में $display का उपयोग

यहाँ हम वास्तविक Verilog कोड उदाहरणों के माध्यम से $display के प्रभावी उपयोग को प्रस्तुत करेंगे, जिसमें टेस्ट बेंच की बुनियाद से लेकर शर्तीय डिबग लॉगिंग तक शामिल है।

बुनियादी उदाहरण: टेस्ट बेंच में आउटपुट

टेस्ट बेंच में $display डालकर आप सिमुलेशन के दौरान व्यवहार देख सकते हैं।

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

इस उदाहरण में, प्रत्येक राइज़िंग क्लॉक reset और count का आउटपुट ट्रिगर करता है। क्योंकि आप टेक्स्ट लॉग के साथ‑साथ वेवफ़ॉर्म भी देख सकते हैं, व्यवहार को ट्रैक करना आसान हो जाता है।

शर्तीय डिस्प्ले उदाहरण

if स्टेटमेंट के साथ मिलाकर आप केवल तब लॉग कर सकते हैं जब विशिष्ट शर्तें पूरी हों।

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

→ इससे आप अनावश्यक लॉग्स से बचते हुए उन घटनाओं को pinpoint कर सकते हैं जिनमें आपकी रुचि है।

डिबग‑मैसेज उदाहरण

डिज़ाइन डिबगिंग के दौरान यह प्रभावी होता है कि आप किसी सिग्नल के “अनपेक्षित स्थिति” में प्रवेश करने पर पकड़ बना सकें।

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

→ आप जल्दी से डिज़ाइन त्रुटियों या अनपेक्षित सिमुलेशन व्यवहार का पता लगा सकते हैं।

कई सिग्नल एक साथ मॉनिटर करना

जब कई सिग्नल आउटपुट कर रहे हों, तो $display के द्वारा उन्हें एक ही लाइन में इकट्ठा करने से लॉग अधिक पठनीय बनते हैं।

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

व्यावहारिक टिप्स का सारांश

• टेस्ट बेंच में $display रखें ताकि प्रगति को विज़ुअलाइज़ किया जा सके
• शर्तीय शाखाओं का उपयोग करके लॉग को परिष्कृत करें
• असामान्यताओं का पता लगाने के लिए चेतावनी संदेश उत्पन्न करें
• पढ़ने में आसानी के लिए कई सिग्नल को एक लाइन में समेकित करें

6. डिस्प्ले‑नियंत्रण अनुप्रयोग (पिक्सेल/टेक्स्ट/इमेज डिस्प्ले)

अब तक हमने सिमुलेशन लॉग के लिए $display का परिचय दिया। वहीं Verilog हार्डवेयर इम्प्लीमेंटेशन (LCD, VGA, HDMI आउटपुट) में “डिस्प्ले कंट्रोल” के लिए भी व्यापक रूप से उपयोग होता है। इस भाग में हम संक्षेप में यह बताएँगे कि हार्डवेयर स्तर पर स्क्रीन डिस्प्ले कैसे लागू किया जाता है।

डिस्प्ले कंट्रोल की मूल अवधारणा

स्क्रीन पर टेक्स्ट या इमेज दिखाने के लिए आपको वीडियो सिग्नल उत्पन्न करने होते हैं, केवल $display का उपयोग नहीं किया जाता। आम तौर पर उपयोग होने वाले कंट्रोल सिग्नल हैं:

• HSYNC (Horizontal Sync) : प्रत्येक लाइन के अंत को दर्शाने वाला सिग्नल
• VSYNC (Vertical Sync) : प्रत्येक फ्रेम के अंत को दर्शाने वाला सिग्नल
• RGB Data : प्रत्येक पिक्सेल के रंग को दर्शाने वाला सिग्नल (उदा., 8‑bit × 3 = 24‑bit कलर)

Verilog में आप इन सिग्नलों को काउंटर और स्टेट‑मशीन के माध्यम से नियंत्रित करते हैं और टाइमिंग के अनुसार आउटपुट करके “स्क्रीन डिस्प्ले” को साकार करते हैं।

उदाहरण 1: कलर बार डिस्प्ले

… (आगे के कोड और विवरण यहाँ रखे जा सकते हैं)

सबसे बुनियादी उदाहरण है डिस्प्ले पर क्षैतिज रूप से रंग बार आउटपुट करना।

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

→ यह स्क्रीन पर क्षैतिज रूप से संरेखित लाल, हरा और नीला रंग बार बनाता है।

उदाहरण 2: टेक्स्ट डिस्प्ले

टेक्स्ट डिस्प्ले के लिए आप फ़ॉन्ट ROM तैयार करते हैं और प्रत्येक अक्षर के डॉट पैटर्न को पिक्सल में बदलते हैं।

// 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

→ यह स्क्रीन पर एक विशेष अक्षर (जैसे “A”) को ड्रॉ करता है।

उदाहरण 3: इमेज डिस्प्ले

इमेज डिस्प्ले करने के लिए आप पूर्व-स्टोर किए गए बिटमैप डेटा (ROM या बाहरी मेमोरी) को पढ़ते हैं और उसे पिक्सल आउटपुट में बदलते हैं।

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

एफपीजीए का उपयोग करने वाले एम्बेडेड सिस्टम में, यह विधि आपको सरल आइकॉन या लोगो डिस्प्ले करने देती है।

डिबग $display की तुलना में अंतर

• $display टेक्स्ट आउटपुट (सिर्फ सिमुलेशन) है
• डिस्प्ले कंट्रोल वीडियो सिग्नल जेनरेशन (हार्डवेयर-इम्प्लीमेंटेबल) है

हालाँकि उनका उद्देश्य अलग है, लेकिन वेरिलॉग सीखने वाले अक्सर इन दोनों को भ्रमित कर देते हैं।

• “मैं सिमुलेशन के दौरान व्यवहार को वेरिफ़ाई करना चाहता हूँ” → $display का उपयोग करें
• “मैं FPGA पर वास्तविक स्क्रीन पर आउटपुट करना चाहता हूँ” → वीडियो‑सिग्नल लॉजिक डिज़ाइन करें

अनुप्रयोगों का विस्तार

• FPGA बोर्ड सीखते समय, वेरिलॉग अक्सर 7‑सेगमेंट LED डिस्प्ले या छोटे LCD डिस्प्ले के लिए उपयोग किया जाता है।
• आगे बढ़ते हुए, आप VGA/HDMI आउटपुट के साथ गेम डेवलपमेंट या GUI डिस्प्ले के लिए सिस्टम बना सकते हैं।
• $display के ज्ञान को डिस्प्ले‑कंट्रोल लॉजिक के साथ मिलाकर आप सिमुलेशन और वास्तविक हार्डवेयर दोनों में “डिस्प्ले” को संभाल सकते हैं।

7. अनुप्रयोग परिदृश्यों के आधार पर उचित उपयोग और टिप्स

जब हम वेरिलॉग में “डिस्प्ले” की बात करते हैं तो दो पहलू होते हैं: सिमुलेशन‑केवल $display टास्क और हार्डवेयर इम्प्लीमेंटेशन डिस्प्ले कंट्रोल। प्रत्येक का सही उपयोग करने से विकास और डिबगिंग दोनों अधिक प्रभावी होते हैं।

सिमुलेशन में उपयोग

1. डिबग लॉग के रूप में $display * महत्वपूर्ण वेरिएबल्स या सिग्नल्स को $display से आउटपुट करें ताकि आप यह जांच सकें कि आपका डिज़ाइन अपेक्षित रूप से व्यवहार कर रहा है या नहीं। * “विशिष्ट शर्तों के तहत मान” या “काउंटर के कुछ बिंदुओं तक पहुँचने” को लॉग्स के माध्यम से वेरिफ़ाई करना कुशल है।
2. अत्यधिक आउटपुट से बचें * हर क्लॉक साइकिल पर आउटपुट देना लॉग्स को भर देता है और पढ़ने में कठिनाई पैदा करता है। शर्तों को सीमित रखें। * उदाहरण: if (state == ERROR) $display("Error occured at %0t", $time);
3. टास्क्स में अंतर करें * $monitor → उन सिग्नल्स के लिए जिन्हें आप लगातार देखना चाहते हैं * $strobe → जब आपको स्थिर मान आउटपुट करने की आवश्यकता हो * $write → फ़ॉर्मेटेड क्षैतिज आउटपुट के लिए

हार्डवेयर डिस्प्ले कंट्रोल में उपयोग

1. सीखने के लिए 7‑सेगमेंट डिस्प्ले * FPGA शुरुआती प्रोजेक्ट्स में, 7‑सेगमेंट LED पर काउंटर वैल्यू डिस्प्ले करना सामान्य है। * $display सिमुलेशन आउटपुट के साथ मिलाकर डिस्प्ले बनाम सिमुलेशन की समझ को गहरा किया जा सकता है।
2. LCD या VGA मॉनिटर कंट्रोल * फ़ॉन्ट ROM या इमेज ROM का उपयोग करके टेक्स्ट या इमेज डिस्प्ले करें। * सिमुलेशन में $display का उपयोग करके आप दोबारा सत्यापित कर सकते हैं कि वीडियो‑सिग्नल जेनरेशन सही है या नहीं।
3. हार्डवेयर में डिबग ओवरले * आप “काउंटर वैल्यू”, “कोऑर्डिनेट्स”, “डिबग मैसेजेज” को वास्तविक वीडियो आउटपुट पर ओवरले कर सकते हैं। * FPGA विकास में यह आम है कि “स्क्रीन स्वयं एक डिबग टूल बन जाए”।

व्यावहारिक टिप्स

• सिमुलेशन → हार्डवेयर फ्लो का पालन करें पहले $display का उपयोग करके सिमुलेशन में व्यवहार की पुष्टि करें, फिर हार्डवेयर कार्यान्वयन के लिए डिस्प्ले‑कंट्रोल लॉजिक पर जाएँ।
• लॉग्स और वेवफ़ॉर्म को साथ में उपयोग करें $display से प्राप्त टेक्स्ट लॉग “इवेंट की समयावधि” दर्शाते हैं, जबकि वेवफ़ॉर्म “विस्तृत ट्रांज़िशन” दिखाते हैं। दोनों का उपयोग डिबगिंग की सटीकता बढ़ाता है।
• टीम विकास में संदेश फ़ॉर्मेट को एकीकृत करें $display संदेश फ़ॉर्मेट (प्रिफिक्स, समय प्रदर्शन आदि) को मानकीकृत करने से कई लोगों के साथ काम करते समय लॉग विश्लेषण आसान हो जाता है।

सारांश

• $display‑प्रकार के टास्क केवल सिमुलेशन “अवलोकन उपकरण” हैं
• डिस्प्ले कंट्रोल का अर्थ हार्डवेयर कार्यान्वयन “डिस्प्ले विधि” है
• प्रत्येक को उचित रूप से उपयोग करके और उन्हें मिलाकर आप प्रभावी विकास सक्षम कर सकते हैं

8. अक्सर पूछे जाने वाले प्रश्न (FAQ)

Q1. $display और $monitor में क्या अंतर है?

A. $display को कॉल किए जाने के क्षण पर एक बार आउटपुट देता है। इसके विपरीत, $monitor स्वचालित रूप से तब आउटपुट करता है जब भी पंजीकृत सिग्नल बदलता है।

• एकबारगी डिबगिंग के लिए → $display
• निरंतर मॉनिटरिंग के लिए → $monitor

Q2. मुझे $strobe कब उपयोग करना चाहिए?

A. $strobe सिमुलेशन साइकिल के अंत में स्थिर (settled) मान आउटपुट करता है। उदाहरण के लिए, जब कई सिग्नल एक ही क्लॉक एज पर एक साथ बदलते हैं, तो $display मध्यवर्ती मान दिखा सकता है। ऐसे मामलों में अंतिम मान दिखाने के लिए $strobe सुविधाजनक है।

Q3. फ़ॉर्मेट स्पेसिफ़ायर %m का उपयोग क्या है?

A. %m वर्तमान मॉड्यूल हायरार्की का नाम आउटपुट करता है। बड़े डिज़ाइनों में, “संदेश किस हायरार्की से आया” को लॉग करने से विश्लेषण बहुत आसान हो जाता है।

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

उदाहरण आउटपुट:

Current module: top.u1.counter

Q4. मेरे लॉग बहुत बड़े हो गए क्योंकि मैंने कई $display उपयोग किए। मुझे क्या करना चाहिए?

A. निम्नलिखित उपाय प्रभावी हैं:

• आउटपुट को फ़िल्टर करने के लिए if स्टेटमेंट्स का उपयोग करें
• केवल त्रुटि पहचान या विशिष्ट इवेंट्स को आउटपुट करें
• न्यूनतम आवश्यक सिग्नल्स को देखने के लिए $monitor का उपयोग करें
• लॉग फ़ाइल में आउटपुट करें और विश्लेषण के दौरान फ़िल्टरिंग टूल्स लागू करें

Q5. क्या $display को सिंथेसिस (FPGA/ASIC) के लिए उपयोग किया जा सकता है?

A. नहीं। $display केवल सिमुलेशन‑केवल टास्क है। सिंथेसिस टूल्स इसे अनदेखा करते हैं, इसलिए यह वास्तविक हार्डवेयर में नहीं दिखता। यदि आप वास्तविक हार्डवेयर पर आउटपुट दिखाना चाहते हैं तो आपको “7‑सेगमेंट LED”, “LCD”, “VGA कंट्रोल लॉजिक” आदि के साथ डिज़ाइन करना होगा।

Q6. वास्तविक हार्डवेयर पर टेक्स्ट या इमेज़ कैसे दिखाएँ?

A. $display से नहीं, बल्कि वीडियो सिग्नल जनरेट करके।

• 7‑सेगमेंट डिस्प्ले → सरल संख्यात्मक या अक्षर डिस्प्ले के लिए
• VGA/LCD → HSYNC, VSYNC, RGB सिग्नल जनरेट करें और उन्हें नियंत्रित करें
• टेक्स्ट → फ़ॉन्ट ROM का उपयोग करके डॉट पैटर्न आउटपुट करें
• इमेज़ → बिटमैप को ROM या बाहरी मेमोरी में स्टोर करके पिक्सेल अनुसार आउटपुट करें

9. निष्कर्ष एवं अगले कदम

इस लेख का सारांश

इस लेख में हमने Verilog में “डिस्प्ले” को मूलभूत से लेकर अनुप्रयोगों तक कवर किया। मुख्य बिंदु शामिल थे:

1. $display की बुनियादें
   • एक सिमुलेशन टास्क जो सिग्नल या वेरिएबल्स को प्रदर्शित करता है, C के printf के समान उपयोगी है।
2. संबंधित टास्कों के अंतर
   • $write → बिना नई लाइन के डिस्प्ले करता है
   • $strobe → सिमुलेशन साइकिल के अंत में स्थिर मान आउटपुट करता है
   • $monitor → स्वचालित रूप से सिग्नल परिवर्तन को मॉनिटर करता है
3. फ़ॉर्मेट स्पेसिफ़ायर का उपयोग
   • %b, %d, %h, %m, %t का उपयोग करके आप अधिक स्पष्ट और व्यावहारिक लॉग बना सकते हैं।
4. व्यावहारिक उदाहरण
   • टेस्ट बेंच में $display डालें ताकि प्रगति मॉनिटर हो सके।
   • शर्तीय संदेशों का उपयोग करके प्रभावी डिबगिंग सक्षम करें।
5. डिस्प्ले कंट्रोल में अनुप्रयोग
   • $display केवल सिमुलेशन के लिए है; हार्डवेयर कार्यान्वयन में HSYNC, VSYNC, RGB का उपयोग करके टेक्स्ट/इमेज़ आउटपुट किया जाता है।
   • 7‑सेगमेंट डिस्प्ले से लेकर उन्नत VGA/HDMI कंट्रोल तक, विस्तार संभव है।

अगले कदम

• SystemVerilog में आगे बढ़ें → उत्तराधिकारी भाषा SystemVerilog में आप अधिक उन्नत डिबग सुविधाओं (assertions, उन्नत $display, आदि) का उपयोग कर सकते हैं।
• वेवफ़ॉर्म व्यूअर के साथ संयोजन → $display लॉग और वेवफ़ॉर्म डेटा को मिलाकर आप संख्यात्मक मानों और ट्रांज़िशन दोनों का विश्लेषण कर सकते हैं, जिससे डिबगिंग की सटीकता बढ़ती है।
• हार्डवेयर डिस्प्ले आउटपुट सीखें → एक छोटे FPGA बोर्ड प्रोजेक्ट में 7‑सेगमेंट या LCD पर आउटपुट करने का प्रयास करें ताकि आप “सिमुलेशन डिस्प्ले” और “हार्डवेयर डिस्प्ले कंट्रोल” के बीच अंतर महसूस कर सकें।
• टीम विकास में लागू करें → $display संदेश फ़ॉर्मेट को मानकीकृत करके आप बहु‑व्यक्ति विकास में लॉग विश्लेषण की दक्षता बढ़ाते हैं।

निष्कर्ष में

$display केवल “टेक्स्ट आउटपुट” से अधिक है। यह सिमुलेशन डिबगिंग के लिए एक शक्तिशाली उपकरण है। और जब आप डिस्प्ले कंट्रोल की दुनिया में कदम रखते हैं, तो आप FPGA के माध्यम से वास्तविक मॉनिटरों पर ग्राफिक्स दिखाने का आनंद अनुभव कर सकते हैं।

मुझे आशा है कि यह लेख Verilog सीखने वालों को “सिमुलेशन डिबगिंग” और “हार्डवेयर डिस्प्ले आउटपुट” दोनों को स्पष्ट रूप से समझने में मदद करेगा।