verilog ट्यूटोरियल
शुरुआत वेरिलोग से हो रही है

algorithm C Language C++ Design patterns GNU/Linux Perl Language Python Language Regular Expressions Scala Language vim
खोज…


टिप्पणियों

वेरिलॉग एक हार्डवेयर विवरण भाषा (एचडीएल) है जिसका उपयोग व्यवहार या रजिस्टर-ट्रांसफर स्तर पर डिजिटल सर्किटरी को डिजाइन करने, अनुकरण और सत्यापित करने के लिए किया जाता है। यह उन कारणों के लिए उल्लेखनीय है जो इसे "पारंपरिक" प्रोग्रामिंग भाषाओं से अलग करते हैं:

  • दो प्रकार के असाइनमेंट, ब्लॉकिंग और नॉन-ब्लॉकिंग हैं, प्रत्येक का अपना उपयोग और शब्दार्थ है।
  • चर को या तो एकल-बिट चौड़ा या स्पष्ट चौड़ाई के साथ घोषित किया जाना चाहिए।
  • डिजाइन पदानुक्रमित हैं, जिसमें वांछित व्यवहार करने वाले मॉड्यूल को त्वरित करने की क्षमता है।
  • सिमुलेशन में (आमतौर पर संश्लेषण में नहीं), wire चर चार राज्यों में से एक में हो सकते हैं: 0, 1, फ्लोटिंग ( z ), और अपरिभाषित ( x )।

संस्करण

संस्करण रिलीज़ की तारीख
वेरिलोग IEEE-1364-1995 1995/01/01
वेरिलोग IEEE-1364-2001 2001/09/28
वेरिलोग IEEE-1364.1-2002 2002/12/18
वेरिलोग IEEE-1364-2005 2006/04/07
SystemVerilog IEEE-1800-2009 2009-12-11
SystemVerilog IEEE-1800-2012 2013-02-21

स्थापना या सेटअप

वेरिलॉग स्थापित करने या स्थापित करने पर विस्तृत निर्देश आपके द्वारा उपयोग किए जाने वाले उपकरण पर निर्भर है क्योंकि कई वेरिलॉग उपकरण हैं।

परिचय

वेरिलोग एक हार्डवेयर विवरण भाषा (एचडीएल) है जिसका उपयोग इलेक्ट्रॉनिक सिस्टम को मॉडल करने के लिए किया जाता है। यह आमतौर पर अमूर्तता के रजिस्टर-स्थानांतरण स्तर (आरटीएल) पर एक इलेक्ट्रॉनिक प्रणाली का वर्णन करता है। इसका उपयोग एनालॉग सर्किट और मिश्रित-सिग्नल सर्किट के सत्यापन में भी किया जाता है। इसकी संरचना और मुख्य सिद्धांत (जैसा कि नीचे वर्णित है) इलेक्ट्रॉनिक प्रणाली का वर्णन करने और सफलतापूर्वक लागू करने के लिए डिज़ाइन किए गए हैं।

  • कठोरता
    एक इलेक्ट्रॉनिक सर्किट एक भौतिक इकाई है जिसमें एक निश्चित संरचना होती है और उसके लिए वेरिलॉग को अनुकूलित किया जाता है। मॉड्यूल (मॉड्यूल), पोर्ट (इनपुट / आउटपुट / इनाउट), कनेक्शन (तार), ब्लॉक (@always), रजिस्टर (रेग) सभी संकलन समय पर तय किए जाते हैं। संस्थाओं और अंतर्संबंधों की संख्या गतिशील रूप से नहीं बदलती है। चिप संरचना (संश्लेषण के लिए) का प्रतिनिधित्व करने वाले शीर्ष स्तर पर हमेशा एक "मॉड्यूल" होता है, और सत्यापन के लिए सिस्टम स्तर पर एक होता है।
  • समानता
    भौतिक चिप में अंतर्निहित एक साथ संचालन हमेशा (सबसे कमोन), प्रारंभिक और कांटा / ब्लॉक में शामिल होने की भाषा में नकल की जाती है। 
  module top();
  reg r1,r2,r3,r4; // 1-bit registers
    initial
    begin
      r1 <= 0 ;
    end
    initial
    begin
      fork
         r2 <= 0 ;
         r3 <= 0 ;
      join
    end
     always @(r4)
        r4 <= 0 ;
 endmodule

उपरोक्त सभी कथनों को एक ही समय इकाई के भीतर समानांतर में निष्पादित किया जाता है।

  • समय और सिंक्रनाइज़ेशन
    वेरिलोग सर्किट की लौकिक प्रकृति का वर्णन करने के लिए विभिन्न निर्माणों का समर्थन करता है। सर्किट में टाइमिंग और देरी को वेरिलॉग में लागू किया जा सकता है, उदाहरण के लिए # डेली निर्माणों द्वारा। इसी तरह, वेरिलॉग भी सिंक्रोनस और अतुल्यकालिक सर्किट के लिए समायोजित करता है और विभिन्न निर्माणों का उपयोग करते हुए फ्लॉप, लैचेज और कॉम्बिनेटरियल लॉजिक जैसे घटक "उदाहरण के लिए" हमेशा ब्लॉक करता है। ब्लॉक का एक सेट भी एक सामान्य घड़ी संकेत के माध्यम से सिंक्रनाइज़ किया जा सकता है या इनपुट के विशिष्ट सेट के आधार पर ब्लॉक को ट्रिगर किया जा सकता है। 

    #10   ;                 // delay for 10 time units
always @(posedge clk )  // synchronous 
always @(sig1 or sig2 ) // combinatorial logic  
@(posedge event1)       // wait for post edge transition of event1
wait (signal  == 1)     // wait for signal to be 1

  • अनिश्चितता
    वेरिलॉग इलेक्ट्रॉनिक सर्किट में निहित कुछ अनिश्चितता का समर्थन करता है। "X" का उपयोग सर्किट की अज्ञात स्थिति का प्रतिनिधित्व करने के लिए किया जाता है। "Z" का उपयोग सर्किट की अपरिवर्तित स्थिति का प्रतिनिधित्व करने के लिए किया जाता है। 

    reg1 = 1'bx;
reg2 = 1'bz;

  • मतिहीनता
    वेरिलॉग अलग-अलग स्तर पर अमूर्त डिजाइनिंग का समर्थन करता है। किसी डिज़ाइन के लिए एब्स्ट्रेक्शन का उच्चतम स्तर रेसिस्टर ट्रांसफ़र लेवल (RTL) है, अगला गेट स्तर है और सबसे निचला सेल स्तर (यूज़र डिफ़ाइन प्राइमेटीज़) है, RTL एब्स्ट्रेक्शन सबसे अधिक इस्तेमाल किया जा रहा है। वेरिलॉग भी डिजाइन के संरचनात्मक बोध के संबंध में अमूर्तता के व्यवहार स्तर का समर्थन करता है, मुख्य रूप से सत्यापन के लिए उपयोग किया जाता है। 

 // Example of a D flip flop at RTL abstraction
module dff (
 clk    , // Clock Input
 reset  , // Reset input
 d       , // Data Input
 q        // Q output
 );
 //-----------Input Ports---------------
 input d, clk, reset ;

 //-----------Output Ports---------------
 output q;

 reg q;

 always @ ( posedge clk)
 if (~reset) begin
   q <= 1'b0;
 end  else begin
   q <= d;
 end

endmodule


// And gate model based at Gate level abstraction 
module and(input x,input y,output o);

wire  w;
// Two instantiations of the module NAND
nand U1(w,x, y); 
nand U2(o, w, w); 

endmodule

// Gate modeled at Cell-level Abstraction
primitive udp_and(
a, // declare three ports
b,
c 
);
output a;   // Outputs
input b,c;  // Inputs 

// UDP function code here
// A = B & C;
table
 // B  C    : A 
    1  1    : 1;
    0  1    : 0;
    1  0    : 0;
    0  0    : 0;
endtable

endprimitive

वेरिलोग के लिए तीन मुख्य उपयोग मामले हैं। वे कोड की संरचना और इसकी व्याख्या निर्धारित करते हैं और उपयोग किए गए टूल सेट भी निर्धारित करते हैं। किसी भी वेरिलॉग डिज़ाइन के सफल कार्यान्वयन के लिए सभी तीन अनुप्रयोग आवश्यक हैं।

  1. शारीरिक डिजाइन / बैक-एंड
    यहाँ Verilog का उपयोग मुख्य रूप से डिज़ाइन को इंटरकनेक्टिंग गेट के मैट्रिक्स के रूप में लॉजिकल डिज़ाइन को लागू करने के लिए देखने के लिए किया जाता है। RTL / तर्क / डिजाइन संश्लेषण से विभिन्न चरणों से गुजरता है -> प्लेसमेंट -> घड़ी का पेड़ निर्माण -> मार्ग -> DRC -> LVS -> टेपआउट करने के लिए। कार्यान्वयन की सटीक प्रकृति के आधार पर सटीक चरण और अनुक्रम भिन्न होते हैं।
  2. सिमुलेशन
    इस उपयोग के मामले में, प्राथमिक उद्देश्य विनिर्देश के अनुसार डिजाइन को मान्य करने के लिए परीक्षण वैक्टर उत्पन्न करना है। इस उपयोग के मामले में लिखे गए कोड को संश्लेषित करने की आवश्यकता नहीं है और यह सत्यापन क्षेत्र में रहता है। यहाँ कोड अधिक बारीकी से जेनेरिक सॉफ्टवेयर संरचनाओं से मिलता जुलता है जैसे कि / जबकि / लूप आदि।
  3. डिज़ाइन
    डिजाइन में सर्किट के विनिर्देश को अमूर्त रूप से RTL स्तर पर लागू करना शामिल है। Verilog कोड तब सत्यापन के लिए दिया जाता है और भौतिक कार्यान्वयन के लिए पूरी तरह से सत्यापित कोड दिया जाता है। कोड केवल वेरिलोग के संश्लेषण योग्य निर्माणों का उपयोग करके लिखा गया है। कुछ RTL कोडिंग स्टाइल सिमुलेशन बनाम सिंथेसिस बेमेल का कारण बन सकते हैं और इनसे बचने के लिए सावधानी बरतनी पड़ती है।

दो मुख्य कार्यान्वयन प्रवाह हैं। वेरीलॉग कोड लिखे और कार्यान्वित करने के तरीके को भी प्रभावित करेगा। कोडिंग की कुछ शैलियों और कुछ संरचनाओं को दूसरे पर एक प्रवाह में अधिक उपयुक्त है।

  • ASIC फ्लो (एप्लिकेशन-विशिष्ट एकीकृत सर्किट)
  • FPGA फ्लो (फील्ड-प्रोग्रामेबल गेट ऐरे) - FPGA और CPLD शामिल हैं

नमस्ते दुनिया

यह उदाहरण इकारस वेरिलॉग कंपाइलर का उपयोग करता है।

चरण 1: एक फाइल बनाएं जिसका नाम है hello.v 

module myModule();

initial
  begin
    $display("Hello World!");   // This will display a message
    $finish ; // This causes the simulation to end.  Without, it would go on..and on.
  end

endmodule

चरण 2. हम इकारस का उपयोग करके .v फ़ाइल संकलित करते हैं: 

>iverilog -o hello.vvp hello.v

-O स्विच आउटपुट ऑब्जेक्ट फ़ाइल को एक नाम प्रदान करता है। इस स्विच के बिना आउटपुट फ़ाइल को a.out कहा जाएगा। Hello.v स्रोत फ़ाइल को संकलित करने का संकेत देता है। जब तक आप इस स्रोत कोड को संकलित नहीं करते हैं, तब तक व्यावहारिक रूप से कोई आउटपुट नहीं होना चाहिए।

चरण 3. आप इस हैलो वर्ल्ड वेरिलॉग प्रोग्राम का अनुकरण करने के लिए तैयार हैं। ऐसा करने के लिए, इस तरह से आह्वान करें: 

>vvp hello.vvp 
Hello World!
>

मैक OSX सिएरा के लिए इकारस वेरिलोग कंपाइलर की स्थापना

  1. ऐप स्टोर से Xcode इंस्टॉल करें।
  2. Xcode डेवलपर टूल इंस्टॉल करें 
> xcode-select --install

यह बुनियादी कमांड लाइन उपकरण प्रदान करेगा जैसे gcc और make

  1. मैक पोर्ट्स स्थापित करें https://www.macports.org/install.php

OSX Sierra Sierra पैकेज मैक प्लेटफॉर्म पर अतिरिक्त सॉफ्टवेयर पैकेजों को स्थापित और अपग्रेड करने का एक ओपन-सोर्स तरीका प्रदान करेगा। मैक के लिए yum या apt-get सोचो।

  1. मैक पोर्ट का उपयोग करके इकारस स्थापित करें 
> sudo port install iverilog
  1. कमांड लाइन से इंस्टॉलेशन को सत्यापित करें 
$ iverilog
iverilog: no source files.

Usage: iverilog [-ESvV] [-B base] [-c cmdfile|-f cmdfile]
                [-g1995|-g2001|-g2005] [-g<feature>]
                [-D macro[=defn]] [-I includedir] [-M depfile] [-m module]
                [-N file] [-o filename] [-p flag=value]
                [-s topmodule] [-t target] [-T min|typ|max]
                [-W class] [-y dir] [-Y suf] source_file(s)

See the man page for details.
$

अब आप मैक पर अपनी पहली वेरिलॉग फ़ाइल को संकलित करने और उसका अनुकरण करने के लिए तैयार हैं।

मैक OSx सिएरा पर सिमुलेशन डेटा के चित्रमय प्रदर्शन के लिए GTKWave स्थापित करें

GTKWave एक पूरी तरह से फीचर ग्राफिकल व्यूइंग पैकेज है जो कई ग्राफिकल डेटा स्टोरेज मानकों का समर्थन करता है, लेकिन यह VCD को सपोर्ट करने के लिए भी होता है, जो कि vvp आउटपुट होगा। इसलिए, GTKWave को लेने के लिए, आपके पास कुछ विकल्प हैं

  1. गोटो http://gtkwave.sourceforge.net/gtkwave.zip और इसे डाउनलोड करें। यह संस्करण आमतौर पर नवीनतम है।
  2. यदि आपने MacPorts ( https://www.macports.org/ ) स्थापित किया है, तो बस sudo port install gtkwave । यह शायद निर्भरता पर स्थापित करना चाहते हैं। ध्यान दें कि यह विधि आमतौर पर आपको एक पुराना संस्करण मिलेगा। यदि आपके पास MacPorts स्थापित नहीं है, तो इस पृष्ठ पर ऐसा करने के लिए एक इंस्टॉलेशन सेटअप उदाहरण है। हाँ! आपको सभी xcode डेवलपर टूल की आवश्यकता होगी, क्योंकि यह विधियां आपको स्रोत से GTKWave "बिल्ड" करेंगी।

जब स्थापना हो जाती है, तो आपको एक अजगर संस्करण का चयन करने के लिए कहा जा सकता है। मेरे पास पहले से ही 2.7.10 स्थापित थे, इसलिए मैंने कभी भी नया नहीं चुना।

इस बिंदु पर आप gtkwave को कमांड लाइन से gtkwave साथ शुरू कर सकते हैं। जब यह शुरू होता है तो आपको XQuarts को स्थापित या अपडेट करने के लिए कहा जा सकता है। ऐसा करो। मेरे मामले में XQuarts 2.7.11 स्थापित है।

नोट: मुझे वास्तव में XQuarts को सही ढंग से प्राप्त करने के लिए रीबूट करने की आवश्यकता है, फिर मैंने gtkwave फिर से टाइप किया और आवेदन आया।

अगले उदाहरण में, मैं दो स्वतंत्र फाइलें, एक टेस्टबैंक और परीक्षण करने के लिए मॉड्यूल बनाऊंगा, और हम डिजाइन देखने के लिए gtkwave का उपयोग करेंगे।

इकारस वेरिलॉग और जीटीकेववेव का उपयोग करना अनुकरणीय रूप से एक डिजाइन को देखने और देखने के लिए

यह उदाहरण इकारस और GTKWave का उपयोग करता है। OSx पर उन टूल के लिए इंस्टॉलेशन निर्देश इस पृष्ठ पर अन्यत्र दिए गए हैं।

मॉड्यूल डिजाइन के साथ शुरू करते हैं। यह मॉड्यूल बीसीडी से 7 सेगमेंट डिस्प्ले है। मैंने डिज़ाइन को मोटे तौर पर एक ऐसे तरीके से कोडित किया है जिससे हमें आसानी से कुछ मिल जाए और हम आसानी से ग्राफिक रूप से फिक्सिंग में बिता सकें। इसलिए हमारे पास एक घड़ी, रीसेट, एक 4 डेटा इनपुट है जो एक बीसीडी मान का प्रतिनिधित्व करता है, और एक 7 बिट आउटपुट जो सात खंड प्रदर्शन का प्रतिनिधित्व करता है। Bcd_to_7seg.v नामक एक फ़ाइल बनाएँ और उसमें नीचे स्रोत रखें। 

module bcd_to_7seg (
   input clk,
   input reset,
   input [3:0] bcd,
   output [6:0] seven_seg_display

);
   parameter TP = 1;
   reg seg_a;
   reg seg_b;
   reg seg_c;
   reg seg_d;
   reg seg_e;
   reg seg_f;
   reg seg_g;

   
   always @ (posedge clk or posedge reset)
      begin
      if (reset)
         begin
            seg_a <= #TP 1'b0;
            seg_b <= #TP 1'b0;
            seg_c <= #TP 1'b0;
            seg_d <= #TP 1'b0;
            seg_e <= #TP 1'b0;
            seg_f <= #TP 1'b0;
            seg_g <= #TP 1'b0;
         end
      else
         begin
            seg_a <= #TP  ~(bcd == 4'h1 || bcd == 4'h4);
            seg_b <= #TP  bcd < 4'h5 || bcd > 6;
            seg_c <= #TP   bcd != 2;
            seg_d <= #TP   bcd == 0 || bcd[3:1] == 3'b001 || bcd == 5 || bcd == 6 || bcd == 8;
            seg_e <= #TP  bcd == 0 || bcd == 2 || bcd == 6 || bcd == 8;
            seg_f <= #TP  bcd == 0 || bcd == 4 || bcd == 5 || bcd == 6 || bcd > 7;
            seg_g <= #TP  (bcd > 1 && bcd < 7) || (bcd > 7);
         end
    end
 
    assign seven_seg_display = {seg_g,seg_f,seg_e,seg_d,seg_c,seg_b,seg_a};
endmodule

अगला, हमें यह जांचने के लिए परीक्षण की आवश्यकता है कि क्या यह मॉड्यूल सही तरीके से काम कर रहा है। टेस्टबेंच में केस स्टेटमेंट वास्तव में मेरी राय में पढ़ना आसान है और यह क्या करता है के रूप में अधिक स्पष्ट है। लेकिन मैं डिजाइन और परीक्षण में एक ही मामले की प्रतिमा लगाने के लिए नहीं चाहता था। यह बुरा अभ्यास है। बल्कि एक-दूसरे को मान्य करने के लिए दो स्वतंत्र डिजाइनों का उपयोग किया जा रहा है।

नीचे दिए गए कोड के साथ, आप दो पंक्तियों $dumpfile("testbench.vcd"); को देखेंगे $dumpfile("testbench.vcd"); और $dumpvars(0,testbench); । ये लाइनें वे हैं जो VCD आउटपुट फ़ाइल बनाती हैं जिनका उपयोग डिज़ाइन के ग्राफ़िकल विश्लेषण करने के लिए किया जाएगा। यदि आप उन्हें छोड़ देते हैं, तो आपको एक वीसीडी फ़ाइल नहीं मिलेगी। Testbench.v नामक एक फ़ाइल बनाएँ और उसमें नीचे स्रोत रखें। 

`timescale 1ns/100ps
module testbench;
reg clk;
reg reset;
reg [31:0] ii;
reg [31:0] error_count;
reg [3:0] bcd;
wire [6:0] seven_seg_display; 
parameter TP = 1;
parameter CLK_HALF_PERIOD = 5;
 
   // assign clk = #CLK_HALF_PERIOD ~clk;  // Create a clock with a period of ten ns
   initial
   begin
     clk = 0;
     #5;
     forever clk = #( CLK_HALF_PERIOD )  ~clk;
   end

   initial
     begin
       $dumpfile("testbench.vcd");
       $dumpvars(0,testbench);
       // clk  = #CLK_HALF_PERIOD ~clk; 
       $display("%0t, Reseting system", $time);
       error_count = 0;
       bcd  = 4'h0;
       reset = #TP 1'b1;
       repeat (30) @ (posedge clk);
       reset  = #TP 1'b0;
       repeat (30) @ (posedge clk);
       $display("%0t, Begin BCD test", $time); // This displays a message


       for (ii = 0; ii < 10; ii = ii + 1)
          begin
          repeat (1) @ (posedge clk);
          bcd  = ii[3:0];
          repeat (1) @ (posedge clk); 
          if (seven_seg_display !== seven_seg_prediction(bcd)) 
             begin
                $display("%0t, ERROR: For BCD %d, module output 0b%07b does not match prediction logic value of 0b%07b.",$time,bcd, seven_seg_display,seven_seg_prediction(bcd));
                error_count = error_count + 1;
             end
          end
       $display("%0t, Test Complete with %d errors", $time, error_count);
       $display("%0t, Test %s", $time, ~|error_count ? "pass." : "fail.");
       $finish ; // This causes the simulation to end.
     end


parameter SEG_A = 7'b0000001;
parameter SEG_B = 7'b0000010;
parameter SEG_C = 7'b0000100;
parameter SEG_D = 7'b0001000;
parameter SEG_E = 7'b0010000;
parameter SEG_F = 7'b0100000;
parameter SEG_G = 7'b1000000;

function [6:0] seven_seg_prediction;
   input [3:0] bcd_in;

   //    +--- A ---+
   //    |         |
   //    F         B
   //    |         |
   //    +--- G ---+
   //    |         |
   //    E         C
   //    |         |
   //    +--- D ---+

   begin
      case (bcd_in)
         4'h0: seven_seg_prediction = SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F;
         4'h1: seven_seg_prediction = SEG_B | SEG_C;
         4'h2: seven_seg_prediction = SEG_A | SEG_B | SEG_G | SEG_E | SEG_D;
         4'h3: seven_seg_prediction = SEG_A | SEG_B | SEG_G | SEG_C | SEG_D;
         4'h4: seven_seg_prediction = SEG_F | SEG_G | SEG_B | SEG_C;
         4'h5: seven_seg_prediction = SEG_A | SEG_F | SEG_G | SEG_C | SEG_D;
         4'h6: seven_seg_prediction = SEG_A | SEG_F | SEG_G | SEG_E | SEG_C | SEG_D;
         4'h7: seven_seg_prediction = SEG_A | SEG_B | SEG_C;
         4'h8: seven_seg_prediction = SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G;
         4'h9: seven_seg_prediction = SEG_A | SEG_F | SEG_G | SEG_B | SEG_C;
         default: seven_seg_prediction = 7'h0;
      endcase
   end
endfunction


bcd_to_7seg u0_bcd_to_7seg (
.clk               (clk),
.reset             (reset),
.bcd               (bcd),
.seven_seg_display (seven_seg_display)
);


endmodule

अब जबकि हमारे पास दो फाइलें हैं, एक testbench.v और bcd_to_7seg.v, हमें इकारस का उपयोग करके संकलन, विस्तृत करने की आवश्यकता है। यह करने के लिए: 

$ iverilog -o testbench.vvp testbench.v bcd_to_7seg.v

आगे हमें अनुकरण करने की आवश्यकता है 

$ vvp testbench.vvp 
LXT2 info: dumpfile testbench.vcd opened for output.
0, Reseting system
6000, Begin BCD test
8000, Test Complete with          0 errors
8000, Test pass.

इस बिंदु पर अगर आप चाहते हैं कि फ़ाइल को वास्तव में परीक्षण किया जा रहा है, तो bcd_2_7seg.v फ़ाइल पर जाएँ और कुछ तर्क को इधर-उधर करें और उन पहले दो चरणों को दोहराएँ।

एक उदाहरण के रूप में मैंने लाइन को seg_c <= #TP bcd != 2; to seg_c <= #TP bcd != 4; । पुनरावर्ती और अनुकरण निम्नलिखित करता है: 

$ iverilog -o testbench.vvp testbench.v bcd_to_7seg.v
$ vvp testbench.vvp 
LXT2 info: dumpfile testbench.vcd opened for output.
0, Reseting system
6000, Begin BCD test
6600, ERROR: For BCD  2, module output 0b1011111 does not match prediction logic value of 0b1011011.
7000, ERROR: For BCD  4, module output 0b1100010 does not match prediction logic value of 0b1100110.
8000, Test Complete with          2 errors
8000, Test fail.
$

तो अब, GTKWave का उपयोग करके सिमुलेशन को देखने देता है। कमांड लाइन से, जारी करें

gtkwave testbench.vcd &

जब GTKWave विंडो दिखाई देती है, तो आप ऊपरी बाएँ हाथ बॉक्स में देखेंगे, मॉड्यूल नाम testbench। इसे क्लिक करें। यह उप-मॉड्यूल, कार्य और उस फ़ाइल से जुड़े कार्यों को प्रकट करेगा। तार और रजिस्टर निचले बाएँ हाथ बॉक्स में भी दिखाई देंगे।

अब तरंग विंडो के बगल में सिग्नल बॉक्स में ड्रैग, क्लक, बीसीडी, एरर_काउंट और सात_सेग_डिसप्ले। अब सिग्नल लगाए जाएंगे। Error_count आपको दिखाएगा कि कौन सा विशेष BCD इनपुट गलत सात_सेग_डिस्प्ले आउटपुट उत्पन्न करता है।

अब आप एक वेरिलॉग बग को ग्राफिक रूप से समस्या निवारण के लिए तैयार हैं।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow