क्या आपने कभी सोचा है कि कंप्यूटर कैसे कुछ कर सकता है जैसे चेक बुक को बैलेंस करना, या शतरंज खेलना , या किसी दस्तावेज़ की वर्तनी जांचना? ये ऐसी चीजें हैं जो कुछ दशक पहले सिर्फ इंसान ही कर सकता था। अब कंप्यूटर उन्हें स्पष्ट रूप से आसानी से करते हैं। सिलिकॉन और तारों से बना "चिप" कुछ ऐसा कैसे कर सकता है जो ऐसा लगता है कि इसके लिए मानव विचार की आवश्यकता है?
यदि आप इस प्रश्न के उत्तर को मूल रूप से समझना चाहते हैं, तो सबसे पहले आपको समझने की आवश्यकता है कि बूलियन तर्क कहा जाता है । मूल रूप से 1800 के दशक के मध्य में जॉर्ज बूले द्वारा विकसित बूलियन तर्क, कुछ अप्रत्याशित चीजों को बिट्स और बाइट्स में मैप करने की अनुमति देता है । बूलियन तर्क के बारे में महान बात यह है कि, एक बार जब आप चीजों को लटका लेते हैं, तो बूलियन तर्क (या कंप्यूटर के संचालन को समझने के लिए आपको कम से कम भागों की आवश्यकता होती है) अपमानजनक रूप से सरल है। इस लेख में, हम पहले सरल तर्क "गेट्स" पर चर्चा करेंगे और फिर देखेंगे कि उन्हें किसी उपयोगी चीज़ में कैसे संयोजित किया जाए।
- सिंपल गेट्स
- सरल योजक
- पूर्ण योजक
- फ्लिप फ्लॉप
- जेके फ्लिप-फ्लॉप
- गेट्स को लागू करना
सिंपल गेट्स
तीन, पांच या सात सरल द्वार हैं जिनके बारे में आपको सीखने की जरूरत है, यह इस बात पर निर्भर करता है कि आप उन्हें कैसे गिनना चाहते हैं (आप देखेंगे कि एक पल में क्यों)। इन सरल फाटकों के साथ आप ऐसे संयोजन बना सकते हैं जो किसी भी डिजिटल घटक को लागू करेंगे जिसकी आप कल्पना कर सकते हैं। ये द्वार यहां थोड़े सूखे और अविश्वसनीय रूप से सरल लगने वाले हैं, लेकिन हम निम्नलिखित अनुभागों में कुछ दिलचस्प संयोजन देखेंगे जो उन्हें और अधिक प्रेरक बना देंगे। यदि आपने पहले से ऐसा नहीं किया है, तो आगे बढ़ने से पहले हाउ बिट्स एंड बाइट्स वर्क पढ़ना मददगार होगा।
गेट नहीं
सबसे सरल संभव गेट को "इन्वर्टर" या नॉट गेट कहा जाता है। यह इनपुट के रूप में एक बिट लेता है और आउटपुट के रूप में इसके विपरीत उत्पादन करता है। तर्क तालिका है:
एक क्यू
0 1
1 0
NOT गेट में A नामक एक इनपुट होता है और Q ("Q" नामक एक आउटपुट आउटपुट के लिए उपयोग किया जाता है क्योंकि यदि आप "O" का उपयोग करते हैं, तो आप इसे आसानी से शून्य के साथ भ्रमित कर देंगे)। तालिका दिखाती है कि गेट कैसे व्यवहार करता है। जब आप A पर 0 लगाते हैं, तो Q 1 उत्पन्न करता है। जब आप A पर 1 लागू करते हैं, तो Q 0 उत्पन्न करता है। सरल।
और गेट
एंड गेट दो इनपुट, ए और बी पर एक तार्किक "और" ऑपरेशन करता है:
एक बीक्यू
0 0 0
0 1 0
1 0 0
१ १ १
AND गेट के पीछे का विचार है, "यदि A और B दोनों 1 हैं, तो Q 1 होना चाहिए।" आप उस व्यवहार को गेट के लिए तर्क तालिका में देख सकते हैं। आप इस तालिका को पंक्ति दर पंक्ति पढ़ें, इस तरह:
एक बीक्यू
0 0 0 यदि A 0 है और B 0 है, तो Q 0 है।
0 1 0 यदि A 0 है और B 1 है, तो Q 0 है।
1 0 0 यदि A 1 है और B 0 है, तो Q 0 है ।
1 1 1 यदि ए 1 है और बी 1 है, तो क्यू 1 है।
या गेट
अगला गेट एक OR गेट है। इसका मूल विचार है, "यदि A 1 है या B 1 है (या दोनों 1 हैं), तो Q 1 है।"
एक बीक्यू
0 0 0
0 1 1
1 0 1
१ १ १
वे तीन बुनियादी द्वार हैं (उन्हें गिनने का यही एक तरीका है)। दो अन्य लोगों को भी पहचानना काफी आम है: नंद और NOR द्वार। ये दो द्वार केवल AND या OR गेट के साथ NOT गेट के संयोजन हैं। यदि आप इन दो द्वारों को शामिल कर लें, तो गिनती बढ़कर पांच हो जाती है। यहाँ NAND और NOR गेट्स का मूल संचालन है - आप देख सकते हैं कि वे AND और OR गेट्स के व्युत्क्रम हैं:
नोर गेट
एक बीक्यू
0 0 1
0 1 0
1 0 0
1 1 0
नंद गेट
एक बीक्यू
0 0 1
0 1 1
1 0 1
1 1 0
अंतिम दो द्वार जिन्हें कभी-कभी सूची में जोड़ा जाता है, वे हैं XOR और XNOR द्वार, जिन्हें क्रमशः "अनन्य या" और "अनन्य और न ही" द्वार के रूप में भी जाना जाता है। यहाँ उनकी तालिकाएँ हैं:
एक्सओआर गेट
एक बीक्यू
0 0 0
0 1 1
1 0 1
1 1 0
एक्सएनओआर गेट
एक बीक्यू
0 0 1
0 1 0
1 0 0
१ १ १
एक्सओआर गेट के पीछे का विचार है, "यदि या तो ए या बी 1 है, लेकिन दोनों नहीं , क्यू 1 है।" एक्सओआर को फाटकों की सूची में शामिल नहीं करने का कारण यह है कि आप इसे सूचीबद्ध मूल तीन गेटों का उपयोग करके आसानी से लागू कर सकते हैं।
यदि आप ए और बी के लिए सभी चार अलग-अलग पैटर्न का प्रयास करते हैं और सर्किट के माध्यम से उनका पता लगाते हैं, तो आप पाएंगे कि क्यू एक एक्सओआर गेट की तरह व्यवहार करता है। चूंकि एक्सओआर गेट्स के लिए एक अच्छी तरह से समझा जाने वाला प्रतीक है, इसलिए आमतौर पर एक्सओआर को "मानक गेट" के रूप में सोचना आसान होता है और इसे उसी तरह से और और या सर्किट आरेखों में उपयोग करना आसान होता है।
सरल योजक
बिट्स और बाइट्स पर लेख में , आपने बाइनरी जोड़ के बारे में सीखा । इस खंड में, आप सीखेंगे कि आप पिछले अनुभाग में वर्णित फाटकों का उपयोग करके बाइनरी जोड़ में सक्षम सर्किट कैसे बना सकते हैं।
आइए सिंगल-बिट योजक से शुरू करें । मान लीजिए कि आपके पास एक प्रोजेक्ट है जहां आपको सिंगल बिट्स को एक साथ जोड़ने और उत्तर प्राप्त करने की आवश्यकता है। जिस तरह से आप उसके लिए एक सर्किट डिजाइन करना शुरू करेंगे, वह यह है कि पहले सभी तार्किक संयोजनों को देखें। आप निम्नलिखित चार राशियों को देखकर ऐसा कर सकते हैं:
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10
यह तब तक ठीक लगता है जब तक आप 1 + 1 तक नहीं पहुंच जाते। उस स्थिति में, आपके पास चिंता करने के लिए वह अजीब कैरी है । यदि आप ले जाने की परवाह नहीं करते हैं (क्योंकि यह, आखिरकार, 1-बिट अतिरिक्त समस्या है), तो आप देख सकते हैं कि आप इस समस्या को XOR गेट से हल कर सकते हैं। लेकिन अगर आप परवाह करते हैं, तो आप हमेशा 2 बिट आउटपुट शामिल करने के लिए अपने समीकरणों को फिर से लिख सकते हैं , जैसे:
0 + 0 = 00
0 + 1 = 01
1 + 0 = 01
1 + 1 = 10
इन समीकरणों से आप तर्क तालिका बना सकते हैं:
कैरी-आउट के साथ 1-बिट योजक
एक बीक्यू सीओ
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
इस तालिका को देखकर आप देख सकते हैं कि आप Q को XOR गेट के साथ और CO (कैरी-आउट) को AND गेट के साथ लागू कर सकते हैं। सरल।
क्या होगा यदि आप दो 8-बिट बाइट्स को एक साथ जोड़ना चाहते हैं? यह थोड़ा कठिन हो जाता है। सबसे आसान समाधान समस्या को पुन: प्रयोज्य घटकों में संशोधित करना और फिर घटकों को दोहराना है। इस मामले में, हमें केवल एक घटक बनाने की आवश्यकता है: एक पूर्ण बाइनरी योजक ।
एक पूर्ण योजक और पिछले योजक के बीच का अंतर जो हमने देखा वह यह है कि एक पूर्ण योजक ए और बी इनपुट और एक कैरी-इन (सीआई) इनपुट स्वीकार करता है । एक बार जब हमारे पास एक पूर्ण योजक होता है, तो हम बाइट-वाइड योजक बनाने के लिए उनमें से आठ को एक साथ स्ट्रिंग कर सकते हैं और कैरी बिट को एक योजक से दूसरे में कैस्केड कर सकते हैं।
अगले भाग में, हम देखेंगे कि एक सर्किट में एक पूर्ण योजक कैसे लागू किया जाता है।
पूर्ण योजक
एक पूर्ण योजक के लिए तर्क तालिका हमारे द्वारा पहले उपयोग की गई तालिकाओं की तुलना में थोड़ी अधिक जटिल है, क्योंकि अब हमारे पास 3 इनपुट बिट हैं । यह इस तरह दिख रहा है:
कैरी-इन और कैरी-आउट के साथ एक-बिट पूर्ण योजक
सीआई ए बीक्यू सीओ
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
१ १ १ १ १ १
आप इस तालिका को लागू करने के कई अलग-अलग तरीके हैं। मैं यहां एक विधि प्रस्तुत करने जा रहा हूं जिसे समझने में आसान होने का लाभ है। यदि आप क्यू बिट को देखते हैं, तो आप देख सकते हैं कि शीर्ष 4 बिट ए और बी के संबंध में एक्सओआर गेट की तरह व्यवहार कर रहे हैं, जबकि नीचे के 4 बिट ए और बी के संबंध में एक्सएनओआर गेट की तरह व्यवहार कर रहे हैं। इसी तरह, CO के शीर्ष 4 बिट A और B के संबंध में AND गेट की तरह व्यवहार कर रहे हैं, और नीचे के 4 बिट OR गेट की तरह व्यवहार कर रहे हैं। उन तथ्यों को लेते हुए, निम्नलिखित सर्किट एक पूर्ण योजक लागू करता है:
यह निश्चित रूप से पूर्ण योजक को लागू करने का सबसे कुशल तरीका नहीं है, लेकिन इस पद्धति का उपयोग करके तर्क को समझना और ट्रेस करना बेहद आसान है। यदि आप इतने इच्छुक हैं, तो देखें कि आप इस तर्क को कम फाटकों के साथ लागू करने के लिए क्या कर सकते हैं।
अब हमारे पास "पूर्ण योजक" नामक कार्यक्षमता का एक टुकड़ा है। फिर एक कंप्यूटर इंजीनियर जो करता है वह "ब्लैक-बॉक्स" होता है ताकि वह घटक के विवरण के बारे में चिंता करना बंद कर सके। एक पूर्ण योजक के लिए एक ब्लैक बॉक्स इस तरह दिखेगा:
उस ब्लैक बॉक्स के साथ, अब 4-बिट पूर्ण योजक बनाना आसान है :
इस आरेख में प्रत्येक बिट से कैरी-आउट सीधे अगले बिट ओवर के कैरी-इन में फीड होता है। A 0 को प्रारंभिक कैरी-इन बिट में हार्ड-वायर्ड किया गया है। यदि आप ए और बी लाइनों पर दो 4-बिट नंबर इनपुट करते हैं, तो आपको क्यू लाइनों पर 4-बिट योग मिलेगा, साथ ही अंतिम कैरी-आउट के लिए 1 अतिरिक्त बिट मिलेगा। आप देख सकते हैं कि यदि आप चाहें तो यह श्रृंखला 8, 16 या 32 बिट्स के माध्यम से जहां तक आप चाहें, विस्तारित हो सकती है।
हमारे द्वारा अभी बनाया गया 4-बिट योजक रिपल-कैरी योजक कहलाता है । इसे यह नाम इसलिए मिलता है क्योंकि कैरी बिट्स एक योजक से दूसरे योजक में "लहर" करता है। इस कार्यान्वयन में सरलता का लाभ है लेकिन गति की समस्याओं का नुकसान है। एक वास्तविक सर्किट में, गेट्स को स्थिति बदलने में समय लगता है (समय नैनोसेकंड के क्रम पर है, लेकिन उच्च गति वाले कंप्यूटरों में नैनोसेकंड मायने रखता है)। इसलिए 32-बिट या 64-बिट रिपल-कैरी एडर्स को कैरी रिपल के कारण अपने अंतिम योग में व्यवस्थित होने में 100 से 200 नैनोसेकंड का समय लग सकता है। इस कारण से, इंजीनियरों ने अधिक उन्नत योजक बनाए हैं जिन्हें कैरी-लुकहेड योजक कहा जाता है । कैरी-लुकहेड को लागू करने के लिए आवश्यक फाटकों की संख्या बड़ी है, लेकिन योजक के लिए बसने का समय बहुत बेहतर है।
फ्लिप फ्लॉप
अधिक दिलचस्प चीजों में से एक जो आप बूलियन गेट्स के साथ कर सकते हैं, वह है उनके साथ मेमोरी बनाना । यदि आप फाटकों को सही ढंग से व्यवस्थित करते हैं, तो वे एक इनपुट मान याद रखेंगे। यह सरल अवधारणा कंप्यूटर में रैम (रैंडम एक्सेस मेमोरी) का आधार है , और यह अन्य उपयोगी सर्किटों की एक विस्तृत विविधता बनाना भी संभव बनाता है।
मेमोरी फीडबैक नामक अवधारणा पर निर्भर करती है । यानी गेट के आउटपुट को वापस इनपुट में फीड किया जाता है। दो इनवर्टर का उपयोग करते हुए सबसे सरल संभव फीडबैक सर्किट ऊपर दिखाया गया है।
यदि आप फीडबैक पथ का अनुसरण करते हैं, तो आप देख सकते हैं कि यदि क्यू 1 होता है, तो यह हमेशा 1 होगा। यदि यह 0 होता है, तो यह हमेशा 0 होगा। चूंकि हमारे द्वारा बनाए गए सर्किट को नियंत्रित करने में सक्षम होना अच्छा है, इसका अधिक उपयोग नहीं है - लेकिन यह आपको यह देखने देता है कि प्रतिक्रिया कैसे काम करती है।
यह पता चला है कि "वास्तविक" सर्किट में, आप वास्तव में इस तरह के सरल इन्वर्टर फीडबैक दृष्टिकोण का उपयोग कर सकते हैं। दो NAND गेटों का उपयोग करते हुए एक अधिक उपयोगी फीडबैक सर्किट नीचे दिखाया गया है:
इस सर्किट में दो इनपुट ( R और S ) और दो आउटपुट ( Q और Q' ) हैं। प्रतिक्रिया के कारण, इसकी तर्क तालिका पहले देखी गई तुलना में थोड़ी असामान्य है:
आर एस क्यू क्यू'
0 0 अवैध
0 1 1 0
1 0 0 1
1 1 याद
तर्क तालिका क्या दिखाती है कि:
- यदि R और S एक दूसरे के विपरीत हैं, तो Q, S का अनुसरण करता है और Q', Q का विलोम है।
- यदि R और S दोनों को एक साथ 1 पर स्विच किया जाता है, तो सर्किट याद रखता है कि पहले R और S पर क्या प्रस्तुत किया गया था।
अजीब अवैध राज्य भी है। इस अवस्था में, R और S दोनों 0 पर जाते हैं, जिसका स्मृति अर्थ में कोई मूल्य नहीं है। अवैध स्थिति के कारण, आप इसे रोकने के लिए आम तौर पर इनपुट पक्ष पर थोड़ा कंडीशनिंग तर्क जोड़ते हैं , जो यहां दिखाया गया है:
इस सर्किट में दो इनपुट (D और E) होते हैं। आप D को "डेटा" और E को "सक्षम करें " के रूप में सोच सकते हैं । यदि E 1 है, तो Q, D का अनुसरण करेगा। यदि E 0 में बदल जाता है, हालांकि, Q को वह याद रहेगा जो पिछली बार D पर देखा गया था। इस तरह से व्यवहार करने वाले सर्किट को आमतौर पर फ्लिप-फ्लॉप कहा जाता है ।
अगले भाग में हम JK फ्लिप-फ्लॉप को देखेंगे।
जेके फ्लिप-फ्लॉप
फ्लिप-फ्लॉप का एक बहुत ही सामान्य रूप जेके फ्लिप-फ्लॉप है । यह स्पष्ट नहीं है, ऐतिहासिक रूप से, "जेके" नाम कहां से आया है, लेकिन इसे आम तौर पर इस तरह एक ब्लैक बॉक्स में दर्शाया जाता है:
इस आरेख में, P का अर्थ "प्रीसेट", C का अर्थ "क्लियर" और Clk का अर्थ "घड़ी" है।
पी सी क्लर्क जे के क्यू क्यू'
1 1 1-से-0 1 0 1 0
1 1 1-से-0 0 1 0 1
1 1 1-से-0 1 1 टॉगल
१ ० एक्स एक्स एक्स ० १
0 1 एक्स एक्स एक्स 1 0
यहाँ तालिका क्या कह रही है: सबसे पहले, प्रीसेट और क्लियर J, K और Clk को पूरी तरह से ओवरराइड करें। तो यदि प्रीसेट 0 पर जाता है, तो Q 1 पर जाता है; और यदि Clear 0 पर जाता है, तो Q 0 पर जाता है, चाहे J, K और Clk कुछ भी कर रहे हों। हालाँकि, यदि प्रीसेट और क्लियर दोनों 1 हैं, तो J, K और Clk काम कर सकते हैं। 1-टू-0 अंकन अर्थ यह है कि जब घड़ी एक 0 करने के लिए एक 1 से बदल जाता है, जम्मू और कश्मीर के मूल्य में याद किया जाता है अगर वे विपरीत हैं। घड़ी के निचले किनारे पर (1 से 0 का संक्रमण), J और K संग्रहीत होते हैं। हालाँकि, यदि J और K दोनों निचले किनारे पर 1 होते हैं, तो Q बस टॉगल करता है । अर्थात् Q अपनी वर्तमान अवस्था से विपरीत अवस्था में परिवर्तित हो जाता है।
आप अभी खुद से पूछ रहे होंगे, "दुनिया में यह किस लिए अच्छा है?" यह पता चला है कि "एज ट्रिगरिंग" की अवधारणा बहुत उपयोगी है। तथ्य यह है कि जेके फ्लिप-फ्लॉप केवल 1 से 0 के संक्रमण पर जेके इनपुट को "लैच" करता है, इसे मेमोरी डिवाइस के रूप में और अधिक उपयोगी बनाता है। जेके फ्लिप-फ्लॉप काउंटरों में भी बेहद उपयोगी होते हैं (जिन्हें डिजिटल घड़ी बनाते समय बड़े पैमाने पर उपयोग किया जाता है )। जेके फ्लिप-फ्लॉप का उपयोग करके 4-बिट काउंटर का एक उदाहरण यहां दिया गया है :
इस सर्किट के आउटपुट ए, बी, सी और डी हैं, और वे 4-बिट बाइनरी नंबर का प्रतिनिधित्व करते हैं। सबसे बाएं फ्लिप-फ्लॉप के क्लॉक इनपुट में 1 से 0 तक और बार-बार 1 में बदलने वाला सिग्नल आता है (एक ऑसिलेटिंग सिग्नल )। काउंटर इस सिग्नल में देखे जाने वाले निचले किनारों की गिनती करेगा। यानी हर बार आने वाला सिग्नल 1 से 0 में बदलता है, A, B, C और D द्वारा दर्शाई गई 4-बिट संख्या 1 से बढ़ जाएगी। तो गिनती 0 से 15 तक जाएगी और फिर वापस 0 पर आ जाएगी। आप आप इस काउंटर में जितने चाहें उतने बिट्स जोड़ सकते हैं और अपनी पसंद की कोई भी चीज़ गिन सकते हैं। उदाहरण के लिए, यदि आप एक दरवाजे पर एक चुंबकीय स्विच लगाते हैं, तो काउंटर दरवाजे के खुलने और बंद होने की संख्या की गणना करेगा। यदि आप सड़क पर एक ऑप्टिकल सेंसर लगाते हैं, तो काउंटर उन कारों की संख्या गिन सकता है जो ड्राइव करती हैं।
जेके फ्लिप-फ्लॉप का एक अन्य उपयोग एज-ट्रिगर लैच बनाना है , जैसा कि यहां दिखाया गया है।
इस व्यवस्था में, घड़ी का किनारा निम्न से उच्च की ओर जाने पर D पर मान "लैच्ड" होता है। कंप्यूटर में सेंट्रल प्रोसेसिंग यूनिट (सीपीयू) और पेरिफेरल्स जैसी चीजों के डिजाइन में कुंडी बेहद महत्वपूर्ण हैं ।
गेट्स को लागू करना
पिछले अनुभागों में हमने देखा कि, बहुत ही सरल बूलियन गेट्स का उपयोग करके, हम एडर्स, काउंटर्स, लैच आदि को लागू कर सकते हैं। यह एक बड़ी उपलब्धि है, क्योंकि अभी कुछ समय पहले केवल मनुष्य ही थे जो दो संख्याओं को एक साथ जोड़ने जैसे काम कर सकते थे। थोड़े से काम के साथ, बूलियन सर्किट को डिज़ाइन करना मुश्किल नहीं है जो घटाव, गुणा, भाग को लागू करता है ... आप देख सकते हैं कि हम पॉकेट कैलकुलेटर से बहुत दूर नहीं हैं। वहां से, यह कंप्यूटर में उपयोग किए जाने वाले पूर्ण विकसित सीपीयू के लिए बहुत दूर नहीं है ।
तो हम वास्तविक जीवन में इन द्वारों को कैसे लागू कर सकते हैं? श्री बोले उनके साथ कागज पर आए, और कागज पर वे बहुत अच्छे लगते हैं। हालांकि, उनका उपयोग करने के लिए, हमें उन्हें भौतिक वास्तविकता में लागू करने की आवश्यकता है ताकि द्वार अपने तर्क को सक्रिय रूप से निष्पादित कर सकें। एक बार जब हम वह छलांग लगा लेते हैं, तो हमने वास्तविक गणना उपकरण बनाने की दिशा में आगे बढ़ना शुरू कर दिया है।
बूलियन तर्क के भौतिक कार्यान्वयन को समझने का सबसे आसान तरीका रिले का उपयोग करना है । वास्तव में, यह है कि कैसे पहले कंप्यूटरों को लागू किया गया था। अब कोई भी कंप्यूटर को रिले के साथ लागू नहीं करता है - आज, लोग सिलिकॉन चिप्स पर उकेरे गए सब-माइक्रोस्कोपिक ट्रांजिस्टर का उपयोग करते हैं। ये ट्रांजिस्टर अविश्वसनीय रूप से छोटे और तेज होते हैं, और वे रिले की तुलना में बहुत कम बिजली की खपत करते हैं। हालांकि, रिले को समझना अविश्वसनीय रूप से आसान है, और वे बूलियन तर्क को बहुत सरलता से लागू कर सकते हैं। उस सादगी के कारण, आप देख पाएंगे कि "कागज पर गेट्स" से "भौतिक वास्तविकता में लागू सक्रिय गेट्स" की मैपिंग संभव और सीधी है। ट्रांजिस्टर के साथ समान मैपिंग करना उतना ही आसान है।
शुरुआत करते हैं इन्वर्टर से। रिले के साथ नॉट गेट को लागू करना आसान है: हम जो करने जा रहे हैं वह बिट स्टेट्स का प्रतिनिधित्व करने के लिए वोल्टेज का उपयोग करता है। हम एक बाइनरी 1 को 6 वोल्ट और बाइनरी 0 को शून्य वोल्ट (जमीन) के रूप में परिभाषित करेंगे। फिर हम अपने सर्किट को पावर देने के लिए 6 वोल्ट की बैटरी का इस्तेमाल करेंगे। इसलिए हमारा NOT गेट इस तरह दिखेगा:
[यदि यह आंकड़ा आपके लिए कोई मायने नहीं रखता है, तो कृपया स्पष्टीकरण के लिए हाउ रिले वर्क्स पढ़ें ।]
आप इस परिपथ में देख सकते हैं कि यदि आप A पर शून्य वोल्ट लगाते हैं, तो आपको Q पर 6 वोल्ट प्राप्त होते हैं; और यदि आप A पर 6 वोल्ट लगाते हैं, तो आपको Q पर शून्य वोल्ट मिलता है। रिले के साथ इन्वर्टर को लागू करना बहुत आसान है!
दो रिले के साथ AND गेट को लागू करना समान रूप से आसान है:
यहाँ आप देख सकते हैं कि यदि आप A और B पर 6 वोल्ट लगाते हैं, तो Q में 6 वोल्ट होंगे। अन्यथा, Q के पास शून्य वोल्ट होगा। ठीक वैसा ही व्यवहार हम AND गेट से चाहते हैं। एक OR गेट और भी सरल है - OR बनाने के लिए A और B के लिए बस दो तारों को एक साथ जोड़ दें। यदि आप चाहें और समानांतर में दो रिले का उपयोग करें तो आप उससे अधिक कट्टर हो सकते हैं।
आप इस चर्चा से देख सकते हैं कि आप रिले से तीन बुनियादी द्वार - NOT, AND और OR - बना सकते हैं। फिर आप भौतिक 8-बिट रिपल-कैरी योजक बनाने के लिए ऊपर दिखाए गए तर्क आरेखों का उपयोग करके उन भौतिक द्वारों को एक साथ जोड़ सकते हैं। यदि आप योजक में ए और बी इनपुट लागू करने के लिए सरल स्विच का उपयोग करते हैं और सभी आठ क्यू लाइनों को प्रकाश बल्बों से जोड़ते हैं, तो आप किसी भी दो नंबरों को एक साथ जोड़ सकते हैं और रोशनी पर परिणाम पढ़ सकते हैं ("लाइट ऑन" = 1, " लाइट ऑफ" = 0)।
सरल फाटकों के रूप में बूलियन तर्क बहुत सीधा है। साधारण फाटकों से आप जोड़ जैसे अधिक जटिल कार्य बना सकते हैं। फाटकों को शारीरिक रूप से लागू करना संभव और आसान है। उन तीन तथ्यों से आपके पास डिजिटल क्रांति का दिल है, और आप मूल रूप से समझते हैं कि कंप्यूटर कैसे काम करता है।
बहुत अधिक जानकारी
संबंधित आलेख
- इलेक्ट्रॉनिक गेट कैसे काम करते हैं
- बिट्स और बाइट्स कैसे काम करते हैं
- माइक्रोप्रोसेसर कैसे काम करते हैं
- डिजिटल घड़ियाँ कैसे काम करती हैं
- रिले कैसे काम करते हैं
- शतरंज कंप्यूटर कैसे काम करते हैं
अधिक बढ़िया लिंक
- इंटरनेट पर बूलियन खोज
- लॉजिक गेट्स और बूलियन बीजगणित
- पीसी मैकेनिक: बूलियन लॉजिक और गेट्स
- नियंत्रण और एंबेडेड सिस्टम: बूलियन लॉजिक
