vhdl
रुको

वाक्य - विन्यास

• [SIGNAL1 [, SIGNAL2 [...]] पर [प्रतीक्षा तक [] समय के लिए] प्रतीक्षा करें;
• रुको; - अनन्त प्रतीक्षा
• s1, s2 पर प्रतीक्षा करें; - संकेत s1 या s2 (या दोनों) बदलने तक प्रतीक्षा करें
• s1 = 15 तक प्रतीक्षा करें; - सिग्नल s1 बदलने तक प्रतीक्षा करें और इसका नया मूल्य 15 है
• 10 एन एस के लिए s1 = 15 तक प्रतीक्षा करें; - सिग्नल s1 में बदलाव होने तक प्रतीक्षा करें और इसका नया मूल्य अधिकतम 10 ns पर 15 है

अनन्त प्रतीक्षा

wait कथन का सरलतम रूप यह है:

wait;

जब भी कोई प्रक्रिया इस पर अमल करती है तो इसे हमेशा के लिए निलंबित कर दिया जाता है। सिमुलेशन अनुसूचक फिर से इसे फिर से शुरू नहीं करेगा। उदाहरण:

signal end_of_simulation: boolean := false;
...
process
begin
  clock <= '0';
  wait for 500 ps;
  clock <= '1';
  wait for 500 ps;
  if end_of_simulation then
    wait;
  end if;
end process;

संवेदनशीलता सूचियाँ और प्रतीक्षा कथन

एक संवेदनशीलता सूची वाली प्रक्रिया में प्रतीक्षा विवरण शामिल नहीं हो सकते हैं। यह समान प्रक्रिया के बराबर है, बिना संवेदनशीलता सूची के और एक और अंतिम कथन के साथ जो है:

wait on <sensitivity_list>;

उदाहरण:

  process(clock, reset)
  begin
    if reset = '1' then
      q <= '0';
    elsif rising_edge(clock) then
      q <= d;
    end if;
  end process;

के बराबर है:

  process
  begin
    if reset = '1' then
      q <= '0';
    elsif rising_edge(clock) then
      q <= d;
    end if;
    wait on clock, reset;
  end process;

VHDL2008 ने all कीवर्ड को संवेदनशीलता सूचियों में पेश किया। यह सभी संकेतों के बराबर है जो प्रक्रिया में कहीं पढ़े जाते हैं । संश्लेषण के लिए दहनशील प्रक्रियाओं को डिजाइन करते समय अपूर्ण संवेदनशीलता सूचियों से बचना विशेष रूप से आसान है। अपूर्ण संवेदनशीलता सूची का उदाहरण:

  process(a, b)
  begin
    if ci = '0' then
      s  <= a xor b;
      co <= a and b;
    else
      s  <= a xnor b;
      co <= a or b;
    end if;
  end process;

ci संकेत संवेदनशीलता सूची का हिस्सा नहीं है और यह बहुत ही कोडिंग त्रुटि है जो संश्लेषण से पहले और बाद में सिमुलेशन बेमेल का कारण बनेगी। सही कोड है:

  process(a, b, ci)
  begin
    if ci = '0' then
      s  <= a xor b;
      co <= a and b;
    else
      s  <= a xnor b;
      co <= a or b;
    end if;
  end process;

VHDL2008 में all कीवर्ड इसे सरल बनाते हैं और जोखिम को कम करते हैं:

  process(all)
  begin
    if ci = '0' then
      s  <= a xor b;
      co <= a and b;
    else
      s  <= a xnor b;
      co <= a or b;
    end if;
  end process;

हालत होने तक प्रतीक्षा करें

on <sensitivity_list> और इसके for <timeout> खंडों को छोड़ना संभव है, जैसे:

    wait until CONDITION;

जो इसके बराबर है:

    wait on LIST until CONDITION;

जहां LIST उन सभी संकेतों की LIST है जो CONDITION में दिखाई देते हैं। यह भी इसके बराबर है:

    loop
      wait on LIST;
      exit when CONDITION;
    end loop;

एक महत्वपूर्ण परिणाम यह है कि यदि इस CONDITION में कोई संकेत नहीं हैं, तो:

    wait until CONDITION;

के बराबर है:

    wait;

इसका एक शास्त्रीय उदाहरण प्रसिद्ध है:

    wait until now = 1 sec;

वह नहीं करता जो कोई सोच सकता था: जैसा कि now एक फ़ंक्शन है, सिग्नल नहीं, इस कथन को निष्पादित करने से प्रक्रिया हमेशा के लिए स्थगित हो जाती है।

एक विशिष्ट अवधि की प्रतीक्षा करें

केवल for <timeout> क्लॉज़ के for <timeout> उपयोग करने पर, एक बिना शर्त प्रतीक्षा करना संभव है जो एक विशिष्ट अवधि तक रहता है। यह संश्लेषित करने योग्य नहीं है (कोई भी वास्तविक हार्डवेयर इस व्यवहार को इतनी सरलता से नहीं कर सकता है), लेकिन अक्सर इसे शेड्यूल करने वाली घटनाओं और एक टेस्टबैंक के भीतर घड़ियों को उत्पन्न करने के लिए उपयोग किया जाता है।

यह उदाहरण परीक्षण के तहत इकाई को चलाने के लिए सिमुलेशन टेस्टबेंच में 100 मेगाहर्ट्ज, 50% कर्तव्य चक्र घड़ी उत्पन्न करता है:

constant period : time := 10 ns;
...
process
begin
   loop
      clk <= '0';
      wait for period/2;
      clk <= '1';
      wait for period/2;
   end loop;
end process;

इस उदाहरण से पता चलता है कि टेस्टबेंच उत्तेजना / विश्लेषण प्रक्रिया का अनुक्रम करने के लिए कोई व्यक्ति शाब्दिक अवधि प्रतीक्षा का उपयोग कैसे कर सकता है:

process
begin
   rst <= '1';
   wait for 50 ns;
   wait until rising_edge(clk); --deassert reset synchronously
   rst <= '0';
   uut_input <= test_constant;
   wait for 100 us; --allow time for the uut to process the input
   if uut_output /= expected_output_constant then
      assert false report "failed test" severity error;
   else
      assert false report "passed first stage" severity note;
      uut_process_stage_2 <= '1';
   end if;
   ...
   wait;
end process;