vhdl
डी-फ्लिप-फ्लॉप (डीएफएफ) और कुंडी

टिप्पणियों

डी-फ्लिप-फ्लॉप (DFF)

सभी उदाहरणों में:

• clk घड़ी है,
• d इनपुट है,
• q उत्पादन है,
• srst एक सक्रिय उच्च तुल्यकालिक रीसेट है,
• srstn एक सक्रिय कम तुल्यकालिक रीसेट है,
• arst एक सक्रिय उच्च अतुल्यकालिक रीसेट है,
• arstn एक सक्रिय निम्न अतुल्यकालिक रीसेट है,
• sset एक सक्रिय उच्च तुल्यकालिक सेट है,
• ssetn एक सक्रिय कम समकालिक सेट है,
• aset एक सक्रिय उच्च अतुल्यकालिक सेट है,
• asetn एक सक्रिय निम्न एसिंक्रोनस सेट है

सभी संकेत प्रकार के हैं ieee.std_logic_1164.std_ulogic । प्रयुक्त सिंटैक्स वह है जो सभी लॉजिक सिंथेसाइज़र के साथ सही संश्लेषण परिणामों की ओर जाता है। वैकल्पिक सिंटैक्स के बारे में चर्चा के लिए कृपया क्लॉक एज डिटेक्शन उदाहरण देखें।

उठती धार घड़ी

process(clk)
begin
  if rising_edge(clk) then
    q <= d;
  end if;
end process;

गिरने की घड़ी

process(clk)
begin
  if falling_edge(clk) then
    q <= d;
  end if;
end process;

बढ़त घड़ी, तुल्यकालिक सक्रिय उच्च रीसेट

process(clk)
begin
  if rising_edge(clk) then
    if srst = '1' then
      q <= '0';
    else
      q <= d;
    end if;
  end if;
end process;

राइजिंग एज क्लॉक, अतुल्यकालिक सक्रिय उच्च रीसेट

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

गिरने की घड़ी, अतुल्यकालिक सक्रिय कम रीसेट, तुल्यकालिक सक्रिय उच्च सेट

process(clk, arstn)
begin
  if arstn = '0' then
    q <= '0';
  elsif falling_edge(clk) then
    if sset = '1' then
      q <= '1';
    else
      q <= d;
    end if;
  end if;
end process;

राइजिंग एज क्लॉक, अतुल्यकालिक सक्रिय उच्च रीसेट, अतुल्यकालिक सक्रिय कम सेट

नोट: सेट में रीसेट से अधिक प्राथमिकता है

process(clk, arst, asetn)
begin
  if asetn = '0' then
    q <= '1';
  elsif arst = '1' then
    q <= '0';
  elsif rising_edge(clk) then
    q <= d;
  end if;
end process;

सिटकनी

सभी उदाहरणों में:

• en सक्षम संकेत है,
• d इनपुट है,
• q उत्पादन है,
• srst एक सक्रिय उच्च तुल्यकालिक रीसेट है,
• srstn एक सक्रिय कम तुल्यकालिक रीसेट है,
• arst एक सक्रिय उच्च अतुल्यकालिक रीसेट है,
• arstn एक सक्रिय निम्न अतुल्यकालिक रीसेट है,
• sset एक सक्रिय उच्च तुल्यकालिक सेट है,
• ssetn एक सक्रिय कम समकालिक सेट है,
• aset एक सक्रिय उच्च अतुल्यकालिक सेट है,
• asetn एक सक्रिय निम्न एसिंक्रोनस सेट है

सभी संकेत प्रकार के हैं ieee.std_logic_1164.std_ulogic । प्रयुक्त सिंटैक्स वह है जो सभी लॉजिक सिंथेसाइज़र के साथ सही संश्लेषण परिणामों की ओर जाता है। वैकल्पिक सिंटैक्स के बारे में चर्चा के लिए कृपया क्लॉक एज डिटेक्शन उदाहरण देखें।

सक्रिय उच्च सक्षम

process(en, d)
begin
  if en = '1' then
    q <= d;
  end if;
end process;

सक्रिय कम सक्षम

process(en, d)
begin
  if en = '0' then
    q <= d;
  end if;
end process;

सक्रिय उच्च सक्षम, तुल्यकालिक सक्रिय उच्च रीसेट

process(en, d)
begin
  if en = '1' then
    if srst = '1' then
      q <= '0';
    else
      q <= d;
    end if;
  end if;
end process;

सक्रिय उच्च सक्षम, अतुल्यकालिक सक्रिय उच्च रीसेट

process(en, d, arst)
begin
  if arst = '1' then
    q <= '0';
  elsif en = '1' then
    q <= d;
  end if;
end process;

सक्रिय कम सक्षम, अतुल्यकालिक सक्रिय कम रीसेट, तुल्यकालिक सक्रिय उच्च सेट

process(en, d, arstn)
begin
  if arstn = '0' then
    q <= '0';
  elsif en = '0' then
    if sset = '1' then
      q <= '1';
    else
      q <= d;
    end if;
  end if;
end process;

सक्रिय उच्च सक्षम, अतुल्यकालिक सक्रिय उच्च रीसेट, अतुल्यकालिक सक्रिय कम सेट

नोट: सेट में रीसेट से अधिक प्राथमिकता है

process(en, d, arst, asetn)
begin
  if asetn = '0' then
    q <= '1';
  elsif arst = '1' then
    q <= '0';
  elsif en = '1' then
    q <= d;
  end if;
end process;

घड़ी की धार का पता लगाने

लघुकथा

Whith VHDL 2008 और अगर घड़ी का प्रकार bit , boolean , ieee.std_logic_1164.std_ulogic या ieee.std_logic_1164.std_logic , बढ़ती बढ़त के लिए एक घड़ी किनारे का पता लगाया जा सकता है

• if rising_edge(clock) then
• if clock'event and clock = '1' then -- type bit, std_ulogic or std_logic
• if clock'event and clock then -- type boolean

और गिरने वाले किनारे के लिए

• if falling_edge(clock) then
• if clock'event and clock = '0' then -- type bit, std_ulogic or std_logic
• if clock'event and not clock then -- type boolean

यह अनुकरण और संश्लेषण दोनों के लिए अपेक्षित व्यवहार करेगा।

नोट: प्रकार std_ulogic संकेत पर एक बढ़ती हुई बढ़त की परिभाषा सरल से थोड़ी अधिक जटिल है if clock'event and clock = '1' then । उदाहरण के लिए, मानक rising_edge फ़ंक्शन की एक अलग परिभाषा है। यहां तक कि अगर यह शायद संश्लेषण के लिए कोई फर्क नहीं पड़ेगा, तो यह अनुकरण के लिए एक बना सकता है।

rising_edge और falling_edge मानक कार्यों के उपयोग को दृढ़ता से प्रोत्साहित किया जाता है। VHDL के पिछले संस्करणों के साथ इन कार्यों के उपयोग को स्पष्ट रूप से मानक संकुल के उपयोग की घोषणा करने की आवश्यकता हो सकती है (जैसे ieee.numeric_bit प्रकार के लिए bit या उन्हें एक कस्टम पैकेज में परिभाषित करने के लिए) भी।

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

लंबी कहानी है

डी-फ्लिप-फ्लॉप (डीएफएफ) मॉडलिंग करते समय एक घड़ी सिग्नल के किनारों का पता लगाने का सही ढंग से वर्णन आवश्यक है। एक धार, परिभाषा के अनुसार, एक विशेष मूल्य से दूसरे में एक संक्रमण है। उदाहरण के लिए, हम टाइप bit के एक संकेत के बढ़ते किनारे (मानक VHDL प्रगणित प्रकार को परिभाषित कर सकते हैं जो दो मान लेता है: '0' और '1' ) '0' से '1' तक संक्रमण के रूप में। टाइप boolean हम इसे false से true संक्रमण के रूप में परिभाषित कर सकते हैं।

अक्सर, अधिक जटिल प्रकार का उपयोग किया जाता है। उदाहरण के लिए, ieee.std_logic_1164.std_ulogic प्रकार, भी एक एनुमरेटेड प्रकार है, जैसे bit या boolean , लेकिन इसमें 2 के बजाय 9 मान हैं:

इस तरह के एक बढ़ते किनारे को परिभाषित करना bit या boolean तुलना में थोड़ा अधिक जटिल है। मसलन, हम यह तय कर सकते हैं कि यह '0' से '1' तक '0' संक्रमण है। लेकिन हम यह भी तय कर सकते हैं कि यह '0' या 'L' से '1' या 'H' संक्रमण है।

नोट: यह इस दूसरी परिभाषा यह है कि के लिए मानक का उपयोग करता है है rising_edge(signal s: std_ulogic) समारोह में परिभाषित ieee.std_logic_1164 ।

किनारों का पता लगाने के विभिन्न तरीकों पर चर्चा करते समय, संकेत के प्रकार पर विचार करना महत्वपूर्ण है। मॉडलिंग लक्ष्य को ध्यान में रखना भी महत्वपूर्ण है: केवल सिमुलेशन या तर्क संश्लेषण? आइए इसे कुछ उदाहरणों पर स्पष्ट करते हैं:

राइजिंग एज डीएफएफ टाइप बिट के साथ

signal clock, d, q: bit;
...
P1: process(clock)
begin
  if clock = '1' then
    q <= d;
  end if;
end process P1;

तकनीकी रूप से, शुद्ध सिमुलेशन शब्दार्थ बिंदु पर, P1 मॉडल एक बढ़ती बढ़त को DFF ट्रिगर करता है। वास्तव में, q <= d असाइनमेंट निष्पादित किया जाता है यदि और केवल यदि:

• clock बदल गई (यह वही है जो संवेदनशीलता सूची व्यक्त करती है) और
• clock का वर्तमान मूल्य '1' ।

जैसे कि clock टाइप बिट की होती है और टाइप बिट में केवल '0' और '1' मान होता है, यह ठीक उसी प्रकार है जिसे हमने टाइप बिट के संकेत के बढ़ते किनारे के रूप में परिभाषित किया है। जैसा कि हम उम्मीद करते हैं, कोई भी सिम्युलेटर इस मॉडल को संभाल लेगा।

नोट: तर्क सिंथेसाइज़र के लिए, चीजें थोड़ी अधिक जटिल हैं, जैसा कि हम बाद में देखेंगे।

असिंक्रोनस एक्टिव हाई रिसेट और टाइप बिट के साथ राइजिंग एज डीएफएफ

हमारे DFF में एक अतुल्यकालिक सक्रिय उच्च रीसेट जोड़ने के लिए, कुछ इस तरह की कोशिश कर सकता है:

signal clock, reset, d, q: bit;
...
P2_BOGUS: process(clock, reset)
begin
  if reset = '1' then
    q <= '0';
  elsif clock = '1' then
    q <= d;
  end if;
end process P2_BOGUS;

लेकिन यह काम नहीं करता है । q <= d असाइनमेंट को निष्पादित करने के लिए शर्त होनी चाहिए: reset = '0' दौरान clock की बढ़ती बढ़त reset = '0' । लेकिन हमने जो मॉडलिंग की है वह है:

• clock या reset या दोनों बदल गए और
• reset = '0' और
• clock = '1'

जो समान नहीं है: यदि clock = '1' reset '1' से '0' , तो clock = '1' असाइनमेंट निष्पादित किया जाएगा, जबकि यह clock की बढ़ती बढ़त नहीं है।

वास्तव में, VHDL में एक सिग्नल विशेषता की मदद के बिना इसे मॉडल करने का कोई तरीका नहीं है:

P2_OK: process(clock, reset)
begin
  if reset = '1' then
    q <= '0';
  elsif clock = '1' and clock'event then
    q <= d;
  end if;
end process P2_OK;

clock'event सिग्नल clock लिए लागू सिग्नल विशेषता event है। यह एक boolean रूप में मूल्यांकन करता है और यह true कि केवल और केवल अगर सिग्नल clock चरण के दौरान सिग्नल clock बदल गई जो कि वर्तमान निष्पादन चरण से पहले थी। इसके लिए धन्यवाद, P2_OK अब पूरी तरह से मॉडल करें जो हम सिमुलेशन (और संश्लेषण) में चाहते हैं।

संश्लेषण शब्दार्थ

कई लॉजिक सिंथेसाइज़र सिंटैक्टिक पैटर्न के आधार पर सिग्नल एज डिटेक्शन की पहचान करते हैं, न कि वीएचडीएल मॉडल के शब्दार्थों पर। दूसरे शब्दों में, वे मानते हैं कि वीएचडीएल कोड कैसा दिखता है, न कि यह किस तरह का व्यवहार करता है। पैटर्न वे सभी को पहचानते हैं:

if clock = '1' and clock'event then

इसलिए, प्रक्रिया P1 के उदाहरण में भी हमें इसका उपयोग करना चाहिए यदि हम चाहते हैं कि हमारा मॉडल सभी तर्क सिंथेसाइज़र द्वारा संश्लेषित किया जाए:

signal clock, d, q: bit;
...
P1_OK: process(clock)
begin
  if clock = '1' and clock'event then
    q <= d;
  end if;
end process P1_OK;

and clock'event हालत का हिस्सा संवेदनशीलता की सूची के साथ पूरी तरह से बेमानी है, लेकिन के रूप में कुछ सिंथेसाइज़र यह जरूरत है ...

एसिंक्रोनस एक्टिव हाई रिसेट और टाइप std_ulogic साथ राइजिंग एज DFF

इस मामले में, घड़ी के बढ़ते किनारे और रीसेट स्थिति को व्यक्त करना जटिल हो सकता है। यदि हम एक ऊपर उठने वाली बढ़त की परिभाषा को बनाए रखते हैं जिसे हमने ऊपर प्रस्तावित किया था और यदि हम मानते हैं कि रीसेट सक्रिय है अगर यह '1' या 'H' , तो मॉडल बन जाता है:

library ieee;
use ieee.std_logic_1164.all;
...
signal clock, reset, d, q: std_ulogic;
...
P4: process(clock, reset)
begin
  if reset = '1' or reset = 'H' then
    q <= '0';
  elsif clock'event and
        (clock'last_value = '0' or clock'last_value = 'L') and
        (clock = '1' or clock = 'H') then
    q <= d;
  end if;
end process P4;

नोट: 'last_value एक और सिग्नल विशेषता है जो सिग्नल को अंतिम मूल्य परिवर्तन से पहले मूल्य देता है।

हेल्पर कार्य करता है

VHDL 2008 मानक सिग्नल किनारों का पता लगाने को आसान बनाने के लिए कई सहायक कार्य प्रदान करता है, खासकर बहु-मूल्यवान एन्यूमरेटेड प्रकार जैसे std_ulogic । std.standard पैकेज को परिभाषित करता है rising_edge और falling_edge प्रकार पर काम करता है bit और boolean और ieee.std_logic_1164 प्रकार पर पैकेज परिभाषित करता है उन्हें std_ulogic और std_logic ।

नोट: वीएचडीएल के पिछले संस्करणों के साथ इन कार्यों के उपयोग के लिए मानक पैकेज (जैसे कि बिट के लिए ieee.numeric_bit) या यहां तक कि उन्हें उपयोगकर्ता पैकेज में परिभाषित करने के लिए स्पष्ट रूप से उपयोग करने की आवश्यकता हो सकती है।

आइए हम पिछले उदाहरणों को फिर से देखें और सहायक कार्यों का उपयोग करें:

signal clock, d, q: bit;
...
P1_OK_NEW: process(clock)
begin
  if rising_edge(clock) then
    q <= d;
  end if;
end process P1_OK_NEW;

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

library ieee;
use ieee.std_logic_1164.all;
...
signal clock, reset, d, q: std_ulogic;
...
P4_NEW: process(clock, reset)
begin
  if reset = '1' then
    q <= '0';
  elsif rising_edge(clock) then
    q <= d;
  end if;
end process P4_NEW;

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