माइक्रोकंट्रोलर्स को क्लॉक की आवश्यकता क्यों होती है


31

निर्देशों को निर्धारित समय अंतराल (यानी एक घड़ी के उपयोग के साथ) पर संसाधित करने की आवश्यकता क्यों है? क्या उन्हें अनुक्रमिक रूप से निष्पादित नहीं किया जा सकता है - पिछले निर्देश के पूरा होने के तुरंत बाद?

माइक्रोकंट्रोलर में घड़ियों की आवश्यकता के लिए एक सादृश्य विशेष रूप से उपयोगी साबित होगा।


6
अतुल्यकालिक प्रोसेसर हैं।
लियोन हेलर

6
आप यह कैसे निर्धारित करेंगे "जब पिछला निर्देश पूरा हो गया है"? यदि आप इसके बारे में सोचते हैं, तो आपको यह जानना होगा कि "पिछला निर्देश पूरा हो गया है?" अभिकलन पूरा हो गया था, और जब "क्या" पिछले निर्देश को पूरा कर लिया है? "अभिकलन" अभिकलन पूरा हो गया है, और ........ यह कहना बहुत आसान है "एक निर्देश को पूरा करने में 0.4 नैनोसेकंड लगते हैं"।
user253751

4
लॉजिक गेट तब नहीं कहते जब वे किए जाते हैं। स्थिर मूल्य पर बसने से पहले संकेत कुछ समय के लिए अनिश्चित होता है। संक्षेप में घड़ी डिजाइन को यह जानने की अनुमति देती है कि तर्क कब सही मूल्य पर व्यवस्थित हो गया है। मशीन के निर्देशों को छोटे टुकड़ों में तोड़कर माइक्रोइन्स्ट्रक्शन जैसी उन्नत रणनीतियाँ मदद करती हैं, इसलिए ADD 4 घड़ी टिक ले सकती है, जबकि मेमोरी एक्सेस सैकड़ों टिक ले सकती है।

जवाबों:


31

एक उदाहरण या दो यहाँ मदद कर सकते हैं। निम्नलिखित काल्पनिक सर्किट पर एक नज़र डालें:

ढांच के रूप में

इस सर्किट का अनुकरण करें - सर्किटलैब का उपयोग करके बनाई गई योजनाबद्ध

मान लें कि ए और बी दोनों शुरू करने के लिए उच्च (1) हैं। AND का आउटपुट 1 है, और चूंकि XOR में दोनों इनपुट 1 हैं, इसलिए आउटपुट 0 है।

तर्क तत्व अपने राज्य को तुरंत नहीं बदलते हैं - इनपुट में परिवर्तन को संभालने के रूप में एक छोटा लेकिन महत्वपूर्ण प्रसार विलंब है। मान लीजिए कि बी कम है (0)। XOR अपने दूसरे इनपुट पर नए राज्य को तुरंत देखता है, लेकिन पहला इनपुट अभी भी AND गेट से 'बासी' 1 देखता है। नतीजतन, आउटपुट संक्षेप में उच्च हो जाता है - लेकिन केवल तब तक जब सिग्नल एंड गेट के माध्यम से फैलता है, दोनों एक्सओआर को कम इनपुट बनाता है, और आउटपुट को फिर से कम करने का कारण बनता है।

ग्लिच सर्किट के संचालन का एक वांछित हिस्सा नहीं है, लेकिन किसी भी समय होने वाली गड़बड़ियां लॉजिक की मात्रा के कारण सर्किट के अलग-अलग हिस्सों के माध्यम से प्रसार गति में अंतर होती हैं, या यहां तक ​​कि सिर्फ तारों की लंबाई भी होती है। ।

संभाल करने के लिए वास्तव में एक आसान तरीका है कि आपके कॉम्बिनेटरियल लॉजिक के आउटपुट पर एक एज-ट्रिगर फ्लिपफ्लॉप डाला जाए, जैसे:

ढांच के रूप में

इस सर्किट का अनुकरण करें

अब, कोई भी ग्लिच जो घटित होती है, फ्लिपफ्लॉप द्वारा सर्किट के बाकी हिस्सों से छिपाई जाती है, जो घड़ी से 0 से 1 तक जाने पर केवल अपनी स्थिति को अपडेट करती है। जब तक बढ़ती हुई घड़ी के किनारों के बीच का अंतराल संकेतों को फैलाने के लिए काफी लंबा होता है। कॉम्बीनेटरियल लॉजिक चेन्स के माध्यम से, परिणाम मज़बूती से निर्धारक और ग्लिच-मुक्त होंगे।


6
वास्तव में लगभग तुरंत देरी से प्रचार प्रसार का उल्लेख करने के लिए धन्यवाद, शायद यह जवाब का 99% है।

1
इस क्रिया का एक कार्यशील उदाहरण माइक्रोचिप (और अन्य) माइक्रोकंट्रोलर्स डिजिटल I / O बाह्य उपकरणों पर देखा जा सकता है। यदि आप लगातार रीड-संशोधित-लिखें निर्देशों का उपयोग करके आउटपुट को अपडेट करने के लिए पोर्ट रजिस्टर (LATCH के बजाय) का उपयोग करते हैं, तो पिन की स्थिति को पढ़ना संभव है, जबकि यह बदलती स्थिति है। अधिक विवरण के लिए dsPIC33E / 24E प्रलेखन की धारा 10.2.2 देखें ।
ईविल डॉग पाई

क्या मैं इसे सही समझता हूं कि अनुक्रमिक सर्किटों को गंभीर रूप से न केवल क्लॉकिंग की जरूरत है, क्योंकि उन्हें ग्लिट्स मिलेंगे, बल्कि इसलिए भी, क्योंकि इस गड़बड़ के कारण कुछ फ्लिप-फ्लॉप गलत मूल्य को स्टोर कर सकते हैं?
डेकेरे

20

मुझे लगता है कि इनमें से बहुत सारे उत्तर मूल प्रश्न पर सटीक रूप से नहीं टिके हैं। माइक्रो-कंट्रोलर में एक घड़ी होती है, क्योंकि यह अनुक्रमिक लॉजिक को निष्पादित (और संचालित करता है) है

डिजिटल सर्किट सिद्धांत में, अनुक्रमिक तर्क एक प्रकार का तर्क सर्किट है जिसका आउटपुट न केवल इसके इनपुट संकेतों के वर्तमान मूल्य पर बल्कि पिछले इनपुट के अनुक्रम पर, इनपुट इतिहास पर निर्भर करता है। यह कॉम्बिनेशन लॉजिक के विपरीत है, जिसका आउटपुट केवल मौजूद इनपुट का एक फंक्शन है। अर्थात्, अनुक्रमिक तर्क में राज्य (स्मृति) होता है, जबकि दहनशील तर्क नहीं होता है। या, दूसरे शब्दों में, अनुक्रमिक तर्क स्मृति के साथ दहनशील तर्क है।

भी:

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


15

संक्षिप्त उत्तर: प्रबंधकों को एक डिजाइन के लिए लाखों (या अधिक) डॉलर देने से पहले फ़ंक्शन का एक सरल, परीक्षण योग्य, PROOF चाहिए। वर्तमान उपकरण, बस उन उत्तरों को अतुल्यकालिक डिजाइन नहीं देते हैं।

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

क्लॉक किए गए तर्क यह साबित करते हैं कि पूरे प्रोसेसर में समय, अपेक्षित वोल्टेज, तापमान और प्रसंस्करण चर पर काम करता है। कई सॉफ्टवेयर उपकरण उपलब्ध हैं जो इस समय को मापने में मदद करते हैं, और शुद्ध प्रक्रिया को "टाइमिंग क्लोजर" कहा जाता है। क्लॉकिंग एक माइक्रोप्रोसेसर में उपयोग की जाने वाली शक्ति के 1/3 से 1/2 के बीच कहीं और (, मेरे अनुभव में करता है ) कर सकता है।

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

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

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

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

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

"पहले-से-आने" "लॉक-आउट" सिग्नल तंत्र को प्राप्त करना एक सर्किट डिजाइन मुद्दा है, और इससे निपटने के ज्ञात तरीके हैं। दौड़ की स्थिति 1 का संकेत है)। खराब डिजाइन अभ्यास; या 2)। प्रोसेसर में आने वाले बाहरी सिग्नल। क्लॉकिंग वास्तव में एक सिग्नल-बनाम-क्लॉक रेस स्थिति का परिचय देता है जो "सेट-अप" और "होल्ड" उल्लंघन से संबंधित है।

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

(आशा है कि ये आपकी मदद करेगा)।

वह सब कहा, अगर आपके पास पैसा है ...


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

वास्तविक दुनिया में घटनाएं अप्रत्याशित समय पर होती हैं। यदि किसी डिवाइस में एक बटन होता है, और माना जाता है कि एक कोड पथ निष्पादित किया जाता है यदि यह "बहुत जल्दी" धकेल दिया जाता है और किसी अन्य कोड पथ को निष्पादित करता है यदि ऐसा नहीं है, तो बटन को धक्का देने पर एक पल के बीच, क्वांटम-मैकेनिकल सीमाओं की अनुपस्थिति में। जहां एक बटन पुश वैकल्पिक कोड पथ को ट्रिगर करने के लिए जल्द ही होगा, और एक पल जहां एक बटन धक्का "बहुत देर हो जाएगी", कुछ सटीक क्षण होंगे जहां एक बटन धक्का दोनों के बीच "कुछ व्यवहार" का कारण होगा (जैसे कार्यक्रम काउंटर के कुछ बिट्स को बदलने के कारण ...
सुपरकैट

... लेकिन दूसरों को नहीं)। क्वांटम-मैकेनिकल सीमाओं की अनुपस्थिति में, अंतिम क्षण के बीच का समय जब धक्का शाखा का कारण होगा, और पहला क्षण जब एक धक्का सफाई से ऐसा करने में विफल होगा, तो मनमाने ढंग से छोटा किया जा सकता है लेकिन शून्य तक कम नहीं किया जा सकता है। क्वांटम-मैकेनिकल सीमा यह संभावना बना सकती है कि कोई भी बटन पुश या तो पहले से रजिस्टर करने के लिए या देर से आने के कारण साफ-साफ विफल हो जाएगा, लेकिन यह साबित करते हुए कि कभी भी क्वांटम राज्य नहीं होगा जो कि घातक मध्यवर्ती समय में एक बटन धक्का की अनुमति देगा। अव्यवहार्य।
सुपरकैट

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

10

माइक्रोकंट्रोलर्स को एक घड़ी का उपयोग करने की आवश्यकता होती है क्योंकि उन्हें किसी भी समय होने वाली घटनाओं का जवाब देने में सक्षम होने की आवश्यकता होती है, जिसमें स्वयं नियंत्रक द्वारा उत्पन्न अन्य बाहरी घटनाओं या घटनाओं के साथ लगभग एक साथ शामिल हैं, और अक्सर कई सर्किट होंगे जिन्हें जानना आवश्यक है कि क्या एक ईवेंट X दूसरे ईवेंट को पूर्ववर्ती करता है। यह कोई मायने नहीं रखता है कि क्या ऐसे सभी सर्किट यह निर्णय लेते हैं कि एक्स पूर्ववर्ती वाई, या ऐसे सभी सर्किट यह निर्णय लेते हैं कि एक्स ने पूर्ववर्ती वाई नहीं लिया था, लेकिन यह अक्सर महत्वपूर्ण होगा कि यदि कोई भी सर्किट तय करता है कि एक्स पूर्व में आता है। Y, तो सभी को ऐसा करना चाहिए। दुर्भाग्य से, यह सुनिश्चित करना मुश्किल है कि सर्किट एक निर्धारित समय के भीतर एक गारंटीकृत सर्वसम्मति तक पहुंच जाएगा, चाहे एक्स एक्स वाई से पहले हो, या यहां तक ​​कि वे आम सहमति पर पहुंच गए हैं या नहीं। तुल्यकालिक तर्क उस के साथ बहुत मदद कर सकता है।

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

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


यह ध्यान देने योग्य है कि जिन राज्यों पर निर्णय लिया जा रहा है वे समान रूप से आंतरिक हो सकते हैं - जैसे कि अंकगणितीय ऑपरेशन का परिणाम। लाइन की लंबाई के कारण देरी का परिणाम देखने वाले MCU के एक हिस्से में हो सकता है - और, एक घड़ी के बिना, उस पर अभिनय करना - अन्य भागों से पहले।
निक जॉनसन

@NickJohnson: यदि अनुक्रम जिस क्रम में किया जाता है वह कभी भी उन चीज़ों पर निर्भर नहीं होता है जिनकी गणना अभी तक नहीं की गई है, तो उन समस्याओं को बिना कठिनाई के हल किया जा सकता है यदि प्रत्येक खंड में ALU जैसे "मान्य" इनपुट और "मान्य" आउटपुट, और चीजें हैं नियत क्रम में होने वाली व्यवस्था की जा सकती है। जहां पहिये गिरते हैं, वह क्रम जिसमें परिचालन होता है, उस समय पर निर्भर होना चाहिए (जैसे यदि किसी के पास समानांतर संचालन की संख्या है जिसे साझा मेमोरी बस का उपयोग करने की आवश्यकता होती है और उनमें से दो समीपवर्ती अनुरोधों को जारी करते हैं, जिनमें से मध्यस्थता पहले जाना चाहिए ...
सुपरकैट

... और जो इंतजार करना चाहिए वह अचूक हो सकता है। यदि कोई पहले से तय कर लेता है कि कौन सा पहले जाने वाला है, तो ऐसी समस्याओं से बचा जा सकता है, लेकिन अगर यह पता चला कि जिस इकाई को पहले जाने के लिए निर्दिष्ट किया गया था, वह दूसरे एक के बाद लंबे समय तक तैयार नहीं होती है, तो परिणाम गंभीर रूप से भुगतना पड़ सकता है। ।
सुपरकैट

यही कारण है कि अंतरिक्ष में जाना इतना कठिन है, संभावनाएं प्रतिकूल रूप से बदलती हैं।
मैजिक स्मोक

6

MCUs एक तुल्यकालिक अनुक्रमिक तर्क सर्किट का केवल एक बहुत ही जटिल उदाहरण हैं। सबसे सरल रूप संभवत: क्लॉकड डी-फ्लिप-फ्लॉप (डी-एफएफ) है, अर्थात एक समकालिक 1 बिट मेमोरी एलिमेंट।

ऐसे स्मृति तत्व हैं जो एसिंक्रोनस हैं, उदाहरण के लिए डी-लैच, जो (एक अर्थ में) डी-एफएफ के एसिंक्रोनस समतुल्य है। एक MCU लाखों ऐसे बुनियादी मेमोरी एलिमेंट्स (D-FF) के गुच्छा से ज्यादा कुछ नहीं है, जो एक साथ लॉजिक गेट्स (मैं ओवरसाइम्प्लीफाइंग) के साथ चिपके हुए हैं।

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

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


5

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

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


3

असल में आप MCU को एक पूर्ण इकाई के रूप में देख रहे हैं, लेकिन सच्चाई यह है कि यह अलग-अलग द्वार और TTL और RTL तर्क से बना है, अक्सर FF सरणी, सभी

को अलग-अलग घड़ी संकेत की आवश्यकता होती है, बस एक पते पर पहुंचने के बारे में अधिक विशिष्ट विचार करने के लिए मेमोरी से, यह सरल कार्य स्वयं कई ऑपरेशन को शामिल कर सकता है जैसे कि डेटा लाइनों और पता-लाइनों के लिए बस उपलब्ध कराना।
कहने का सबसे अच्छा तरीका है, निर्देश स्वयं ऑपरेशन की छोटी इकाइयों में होते हैं, जिन्हें घड़ी चक्र की आवश्यकता होती है, ये मशीन चक्र के लिए संयुक्त होते हैं , जो गति के विभिन्न MCU गुणों (जैसे जटिल MCU में FLOPS **), पाइप लाइनिंग आदि के लिए

जवाब देते हैं। ओपी की टिप्पणी

बहुत सटीक होने के लिए, मैं आपको एक उदाहरण देता हूं जिसमें एक चिप है ALE(एड्रेस लैच इनेबल) आमतौर पर एक ही पिन पर एड्रेस और डेटा दोनों ट्रांसमिट करने के लिए लोअर एड्रेस बस को मल्टीप्लेक्स करने के उद्देश्य से, हम एड्रेस और फिर डेटा लाने के लिए एक ऑसिलेटर्स (घड़ी के रूप में इंटेल 8051 11.059 मेगाहर्ट्ज लोकल ऑसिलेटर का इस्तेमाल करते हैं) का इस्तेमाल करते हैं।

जैसा कि आप जानते हैं कि MCU के मूल भाग CPU, ALU और आंतरिक रजिस्टर हैं और इसी तरह, CPU (s / g को नियंत्रित करना) 8051 के मामले में सभी पता पिन 16 को पता भेजता है, यह समय तत्काल T1 और उसके बाद होता है पता संधारित्र भंडारण की एक समान मैट्रिक्स है (एक संकेत के रूप में चार्ज) ( * मेमोरी मैपिंग * ) सक्रिय और चयनित है।

चयन के बाद ALE सिग्नल सक्रिय होता है यानी ALE पिन अगली घड़ी में T2 कहते हैं ( आमतौर पर एक उच्च संकेत लेकिन प्रसंस्करण इकाई डिजाइन के अनुसार परिवर्तन) में उच्च बनाया जाता है , इसके बाद निचले पते की बसें डेटा लाइनों की तरह काम करती हैं, और डेटा लिखा या पढ़ा जाता है (MCU के RD / WR पिन-इन पर आउटपुट के आधार पर)।
आप स्पष्ट रूप से देख सकते हैं कि सभी घटनाएं समय पर अनुक्रमिक हैं

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


उस तरह की समझ में आता है। लेकिन एमसीयू के इन विभिन्न डिब्बों को संचालित करने के लिए क्लॉक सिग्नल की आवश्यकता क्यों है? यदि वे घड़ी का उपयोग नहीं करते तो सैद्धांतिक रूप से क्या होगा?
एमआर

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

3
@ सीनबॉडी: लॉजिक गेट्स तुरंत राज्य का मौका नहीं देते हैं, एक छोटा अंतराल है जो एक आस्टसीलस्कप पर देखा जा सकता है। यदि हम घड़ी का उपयोग नहीं करते हैं, तो घटकों के बीच इन समय के अंतर से गलत परिणाम उत्पन्न करने वाली नस्ल की स्थिति पैदा हो सकती है।
ब्लूराजा - डैनी पफ्लुगुफ्ट

@BlueRaja - अच्छी तरह से अच्छी गमड्रॉप, कैसे के बारे में। हो सकता है कि मैं 4 साल के पावर इलेक्ट्रॉनिक्स नोट्स और 8 साल की नेवी ट्रेनिंग के माध्यम से यह पता लगाने के लिए वापस जाऊं कि मुझे एक चीज कहां याद आई।
सीन बोडी

2

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

एक सादृश्य के रूप में, SPI (सीरियल पेरिफेरल इंटरफ़ेस) संचार परिवहन परत पर विचार करें। इसका एक विशिष्ट कार्यान्वयन तीन लाइनों का उपयोग करेगा: डेटा इन, डेटा आउट और क्लॉक। इस ट्रांसपोर्ट लेयर पर एक बाइट भेजने के लिए, मास्टर अपनी डेटा आउट लाइन सेट करेगा और क्लॉक लाइन को यह दर्शाने के लिए बताएगा कि डेटा आउट लाइन का वैध मूल्य है। गुलाम डिवाइस अपने डेटा को लाइन में तभी देखेगी जब उसे क्लॉक सिग्नल द्वारा ऐसा करने का निर्देश दिया गया हो। यदि कोई घड़ी संकेत नहीं थे, तो गुलाम को कैसे पता चलेगा कि डेटा इन लाइन का नमूना कब बनाया गया? यह मास्टर द्वारा या राज्यों के बीच संक्रमण के दौरान लाइन सेट करने से पहले इसका नमूना ले सकता था। असिंक्रोनस प्रोटोकॉल, जैसे CAN, RS485, RS422, RS232, आदि इसे पूर्व-परिभाषित नमूना समय, निश्चित बिट दर और (ओवरहेड) फ्रेमिंग बिट्स का उपयोग करके हल करते हैं।

दूसरे शब्दों में, यह निर्धारित करने के लिए किसी प्रकार का सामान्य ज्ञान आवश्यक है जब फाटकों के एक सेट में सभी ट्रांजिस्टर अपने अंतिम स्थिति में पहुंच गए हैं और निर्देश पूरा हो गया है। ऊपर दिए गए लिंक में बताई गई (100 नीली आंखों) पहेली, और मैथ्स स्टैक एक्सचेंज पर इस प्रश्न में कुछ विस्तार से बताया गया है , 'ओरेकल' द्वीप पर लोगों के लिए घड़ी के रूप में कार्य करता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.