प्रोसेसर

जहां तक ​​मुझे याद है, मैंने हमेशा एक प्रोसेसर बनाने का सपना देखा था। अंत में, कल मैंने इसे बनाया। भगवान जानते हैं कि: 8 बिट्स, RISC, वर्तमान ऑपरेटिंग आवृत्ति 4 kHz है, लेकिन यह काम करता है। अब तक तार्किक सर्किट मॉडलिंग के कार्यक्रम में, लेकिन हम सभी जानते हैं: "आज - मॉडल पर, कल - व्यवहार में!"।

कट के तहत कई एनिमेशन हैं, सबसे छोटे के लिए बाइनरी लॉजिक का एक संक्षिप्त परिचय, मुख्य प्रोसेसर लॉजिक चिप्स के बारे में एक छोटी कहानी और, वास्तव में, सर्किट।

द्विआधारी तर्क

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

बफर तत्व

कल्पना करें कि आप अपने कमरे में बैठे हैं, और आपका दोस्त रसोई में है। आप उसे चिल्लाते हैं: "दोस्त, मुझे बताओ, गलियारे में रोशनी है?" एक मित्र उत्तर देता है: "हाँ, यह चालू है!" या "नहीं, यह चालू नहीं है।" आपका मित्र सिग्नल स्रोत (दालान में एक प्रकाश) और रिसीवर (आप) के बीच एक बफर है। इसके अलावा, आपका दोस्त एक नियमित बफर नहीं है, लेकिन एक प्रबंधित बफर है। अगर यह लगातार चिल्लाया जाए तो यह एक साधारण बफर होगा: "प्रकाश चालू है" या "प्रकाश चालू नहीं है"।

तत्व "नहीं" - नहीं

अब कल्पना करें कि आपका दोस्त एक जोकर है जो हमेशा झूठ कहता है। और यदि गलियारे में प्रकाश जलाया जाता है, तो वह आपको बताएगा "नहीं, यह गलियारे में बहुत अंधेरा है", और यदि यह जलाया नहीं जाता है, तो "हां, प्रकाश गलियारे में है"। यदि आपके पास वास्तव में ऐसा दोस्त है, तो वह तत्व का अवतार है "नहीं।"

या तत्व - या

दुर्भाग्य से, एक बल्ब और एक दोस्त "या" तत्व का सार समझाने के लिए पर्याप्त नहीं होगा। दो बल्ब चाहिए। तो, आपके पास गलियारे में दो रोशनी हैं - एक मंजिल दीपक, उदाहरण के लिए, और एक झूमर। आप चिल्लाते हैं: "दोस्त, मुझे बताओ, क्या दालान में कम से कम एक रोशनी चमकती है?", और आपका दोस्त "हां" या "नहीं" का जवाब देता है। जाहिर है, जवाब "नहीं" के लिए सभी रोशनी को बंद करना होगा।

और तत्व - और

एक ही अपार्टमेंट, आप, रसोई में एक दोस्त, एक फर्श दीपक और दालान में एक झूमर। आपके प्रश्न के लिए "क्या दोनों गलियारे में रोशनी हैं?" आपको उत्तर "हां" या "नहीं" मिलता है। बधाई हो, अब आपका मित्र एक AND तत्व है।

विशिष्ट या तत्व - XOR

आइए हम "या" तत्व के लिए फिर से प्रयोग दोहराएं, लेकिन हम अपने प्रश्न को एक मित्र को सुधारते हैं: "मित्र, मुझे बताओ, क्या दालान में केवल एक ही प्रकाश है?"। एक ईमानदार दोस्त इस सवाल का जवाब "हां" केवल तभी देगा जब गलियारे में वास्तव में केवल एक प्रकाश हो।

एडर

कुल चौथाई

क्वार्टर-योजक को विशेष या तत्व कहा जाता है। क्यों? चलिए इसका पता लगाते हैं।
आइए बाइनरी नंबर सिस्टम में दो नंबरों के लिए अतिरिक्त तालिका बनाएं:
० + ० = ०
0 + 1 = 1
१ + ० = १
1 + 1 = 10

अब हम "विशेष या" तत्व की सत्य तालिका को लिखते हैं। ऐसा करने के लिए, हम चमकदार बल्ब को 1, विलुप्त वाले को 0 के रूप में और दोस्त के जवाबों को क्रमशः "हां" / "नहीं" के रूप में 1 और 0 के रूप में दर्शाते हैं।
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0

बहुत समान है, है ना? एक विशेष मामले को छोड़कर, अतिरिक्त तालिका और "अनन्य या" की सत्य तालिका पूरी तरह से मेल खाती है। और इस मामले को ओवरफ्लो कहा जाता है।

आधा योजक

ओवरफ्लो करते समय, जोड़ के परिणाम उतने अंकों में नहीं आते जितने शब्दों को रखा गया था। शब्द दो एकल-अंकीय संख्याएँ हैं (एक महत्वपूर्ण अंक, समझें?), और योग पहले से ही दो-अंकीय संख्याएँ हैं (दो महत्वपूर्ण अंक)। एक प्रकाश ("पर" / "बंद") के साथ दो अंकों को अब प्रसारित नहीं किया जा सकता है। दो बल्ब चाहिए। हमें ज़रूरत है - हम इसे करेंगे!


एक्सओआर के अलावा, योजक के लिए हमें तत्व "और" (और) की आवश्यकता होती है।
0 XOR 0 = 0 0 और 0 = 0
0 XOR 1 = 1 0 और 1 = 0
1 XOR 0 = 1 1 और 0 = 0
1 XOR 1 = 0 1 और 1 = 1

Tadam!
0 + 0 = 00
0 + 1 = 01
१ + ० = ०१
1 + 1 = 10

हमारे wunderwafer अर्ध-योजक काम करता है। यह सबसे सरल विशेष प्रोसेसर माना जा सकता है जो दो नंबर जोड़ता है। एक अर्ध-योजक को आधा-योजक कहा जाता है क्योंकि इसका उपयोग हस्तांतरण (किसी अन्य योजक का परिणाम) को ध्यान में रखने के लिए नहीं किया जा सकता है, अर्थात, आप तीन एकल-अंकीय बाइनरी संख्याओं को नहीं जोड़ सकते हैं। इस संबंध में, एक मल्टी-बिट कई सिंगल-बिट आधा-योजक से नहीं बनाया जा सकता है।

मैं पूर्ण और बहु-अंकों के जोड़ियों के काम के विवरण में नहीं जाऊंगा, मुझे उम्मीद है कि आपने मुख्य विचार को पकड़ लिया है।

अधिक जटिल तत्व

बहुसंकेतक

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

मल्टीप्लेक्स आमतौर पर केवल "और", "या" और "नहीं" तत्वों के संयोजन से युक्त होते हैं। सिंगल-बिट मल्टीप्लेक्स में एक इनपुट होता है जिसे "एड्रेस सिलेक्शन" कहा जाता है, सामान्य इनपुट के साथ दो इनपुट "इनपुट सिग्नल" और एक आउटपुट, जिसे "आउटपुट सिग्नल" कहा जाता है।
जब 0 "पता चयन" पर लागू होता है, तो "आउटपुट सिग्नल" पहले "इनपुट सिग्नल" के समान हो जाता है। तदनुसार, जब 1 को "चयन" पर लागू किया जाता है, तो "आउटपुट सिग्नल" दूसरे "इनपुट सिग्नल" के बराबर हो जाता है।

demultiplexer

लेकिन यह बात ठीक इसके विपरीत काम करती है। हम "पता चयन" को पता देते हैं, हम डेटा को "डेटा इनपुट" देते हैं, हमारे पास आउटपुट डेटा इनपुट नंबर के साथ होता है।

काउंटर

काउंटर के संचालन को समझने के लिए, आपको फिर से अपने दोस्त की आवश्यकता होगी। उसे रसोई से बुलाओ (मुझे उम्मीद है कि वह वहां ऊब नहीं गया था, और, सबसे महत्वपूर्ण बात, यह सब आपके भोजन का नहीं है), और उसे ऐसा करने के लिए कहें: उसे नंबर याद रखें 0. हर बार जब आप उसे छूते हैं, तो उसे एक जोड़ना होगा जो नंबर याद है, उसे रिजल्ट बताएं और याद रखें। जब परिणाम (3) है, तो उसे "अब्रकदबरा!" चिल्लाना चाहिए और अगली बार जवाब देना चाहिए कि वह संख्या 0 को याद करता है। अब क्या यह थोड़ा जटिल है? देखें:

आप एक दोस्त को छू रहे हैं। एक दोस्त कहता है "एक।"
आप एक दोस्त को छू रहे हैं। एक दोस्त कहता है "दो।"
आप एक दोस्त को छू रहे हैं। एक दोस्त कहता है "तीन।" एक दोस्त चिल्लाता है “ हब्बर! "। गंभीर हमला! आप अस्थायी रूप से लकवाग्रस्त हैं और चल नहीं सकते।
आप एक दोस्त को छू रहे हैं। एक दोस्त कहता है "ज़ीरो।"

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

स्मृति

ट्रिगर

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

रजिस्टर

रजिस्टर थोड़ा और अधिक जटिल है। आपका दोस्त एक रजिस्टर में बदल जाता है जब आप उसे कुछ याद करने के लिए कहते हैं, और फिर कहते हैं "अरे, मुझे याद करो कि मैंने तुम्हें याद करने के लिए क्या कहा था?", और दोस्त सही जवाब देता है।

एक रजिस्टर आमतौर पर एक से थोड़ा अधिक स्टोर कर सकता है। इसमें डेटा इनपुट, डेटा आउटपुट और अनुमति इनपुट लिखना होगा। डेटा के आउटपुट से, आप किसी भी समय पढ़ सकते हैं कि इस रजिस्टर में क्या लिखा गया है। डेटा इनपुट पर आप उस डेटा को सबमिट कर सकते हैं जिसे आप इस रजिस्टर पर लिखना चाहते हैं। जब तक आप ऊब नहीं जाते तब तक आप डेटा जमा कर सकते हैं। वैसे भी, रजिस्टर में तब तक कुछ भी नहीं लिखा जाएगा जब तक कि आप एक, "तार्किक इकाई", लिखित अनुमति के इनपुट पर दर्ज न करें।

शिफ्ट रजिस्टर

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

तो, शिफ्ट रजिस्टर में एक डेटा इनपुट होता है (जिसके माध्यम से डेटा "कतार" में गिर जाता है) और डेटा आउटपुट (जिससे आप "कतार" में बहुत पहले रिकॉर्ड पढ़ सकते हैं)। शिफ्ट रजिस्टर में एक इनपुट "शिफ्ट रजिस्टर" भी होता है। जैसे ही एक "तार्किक इकाई" इस इनपुट पर आती है, पूरी कतार स्थानांतरित हो जाती है।

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

बिना सोचे समझे याद करना

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

प्रोसेसर

BitBitJump

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

इस भाषा के लिए बिटबिटजम्प और असेंबलर का विस्तृत विवरण डेवलपर की वेबसाइट पर पाया जा सकता है। प्रोसेसर एल्गोरिथ्म का वर्णन करने के लिए, यह निम्नलिखित को जानने के लिए पर्याप्त है:
1. जब आप रजिस्टरों में प्रोसेसर को चालू करते हैं तो पीसी, ए और बी 0 लिखा होता है
2. पीसी पते के साथ मेमोरी लोकेशन पढ़ें और रजिस्टर ए में रीड को सेव करें
3. पीसी बढ़ाएँ
4. पीसी पते के साथ मेमोरी लोकेशन पढ़ें और रजिस्टर बी में रीड को सेव करें
5. पीसी बढ़ाएं
6. हम रजिस्टर बी में दर्ज पते के साथ सेल में लिखते हैं, पता ए के साथ बिट की सामग्री।
7. पीसी पते के साथ मेमोरी लोकेशन पढ़ें और रजिस्टर बी में रीड को सेव करें
8. रजिस्टर बी से पीसी रजिस्टर तक की सामग्री लिखें
9. हम अपनी योजना के अनुच्छेद 2 पर आगे बढ़ते हैं।
10. लाभ !!!

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

दरअसल, योजना

यह योजना अनायास बनी थी, इसलिए इसमें भय, भय और भ्रम का शासन था। हालांकि, यह काम करता है, और शालीनता से काम करता है। प्रोसेसर चालू करने के लिए, आपको आवश्यकता है:
1. रैम में प्रोग्राम दर्ज करें
2. स्विच दबाएं
3. काउंटर को स्थिति 4 पर सेट करें (यह हार्डवेयर में भी किया जा सकता है, लेकिन सर्किट और भी अधिक बोझिल हो जाएगा)
4. घड़ी चालू करें

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



आप लॉजिम के लिए सर्किट को सर्किल प्रारूप में डाउनलोड कर सकते हैं और खेल सकते हैं।

आगे क्या है?

सबसे पहले, आप प्रोसेसर की क्षमता बढ़ा सकते हैं - 16-बिट वाले 8-बिट तत्वों की जगह।
दूसरे, आप प्रोसेसर से रैम को हटा सकते हैं, और एक सरल सर्किट जोड़ सकते हैं जो प्रोसेसर को रोक देगा, रैम को बदल देगा और प्रोसेसर को फिर से चालू करेगा। ऐसा सर्किट एक साधारण I / O नियंत्रक के रूप में काम करेगा। फिर इस प्रोसेसर के आधार पर एक कैलकुलेटर, एक नियंत्रक या कुछ अन्य अजीब बेकार चीज बनाना संभव होगा।
तीसरा, इस पूरी योजना को हार्डवेयर में लागू करना संभव है। मैं क्या करने जा रहा हूँ जैसे ही मैं करता हूं, मैं निश्चित रूप से बताऊंगा और दिखाऊंगा।

आपका ध्यान देने के लिए आप सभी का धन्यवाद!

पुनश्च लिंक (उन लोगों के लिए जो पढ़ने में बहुत आलसी हैं):
1. URISC प्रोसेसर - en.wikipedia.org/wiki/Urisc
2. BitBitJump भाषा साइट - mazonka.com/bbj/index.html
3. लॉजिस्म लॉजिक मॉडलिंग प्रोग्राम - http://ozark.hendrix.edu/~burch/logisim/
4. Logisim के लिए होम-निर्मित URISC (ORISC) प्रोसेसर - narod.ru/disk/31367690001/oo.circ.html