कंप्यूटर को मशीनी भाषा में कोड और टेस्ट करें: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:20

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

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

कंप्यूटर डिज़ाइन के लिए, मैंने अपनी किंडल ई-बुक बिल्ड योर ओन कंप्यूटर - फ्रॉम स्क्रैच से एक को अनुकूलित किया। मैंने वहां वर्णित BYOC कंप्यूटर के साथ शुरुआत की और इसे अलग-अलग मूल BYOC-I (I for Instructable) में ट्रिम कर दिया, जिसका उपयोग हम इस निर्देश में करेंगे।

BYOC-I की मशीनी भाषा सरल और समझने में आसान है। आपको कंप्यूटर या प्रोग्रामिंग के किसी विशेष ज्ञान की आवश्यकता नहीं होगी। केवल एक जिज्ञासु मन और सीखने की इच्छा की आवश्यकता है।

आगे की पढाई

आपको आश्चर्य हो सकता है कि हम कंप्यूटर का वर्णन करने के लिए "मशीन" का उपयोग क्यों करते हैं जबकि यह एक यांत्रिक उपकरण नहीं है। कारण ऐतिहासिक है; पहले कंप्यूटिंग उपकरण यांत्रिक थे जिनमें गियर और पहिए होते थे। एलन शर्मन का गीत, "इट्स इज ऑल गियर्स गोइंग क्लिक्टी-क्लैक …" केवल एक या दो शताब्दी का था। यहां प्रारंभिक कंप्यूटिंग के बारे में और पढ़ें।

चरण 1: भागों की सूची

भागों की सूची छोटी है। केवल इन दो वस्तुओं की आवश्यकता है, दोनों डाउनलोड करने योग्य मुफ्त:

1. "Logisim-win-2.7.1.exe" - Logisim एक लोकप्रिय और उपयोग में आसान लॉजिक सिम्युलेटर है। यहां से Logisim निष्पादन योग्य फ़ाइल डाउनलोड करें और फिर अपने डेस्कटॉप जैसी सुविधाजनक जगह पर एक छोटा कट बनाएं। इसे लॉन्च करने के लिए Logisim आइकन पर डबल क्लिक करें। नोट: Logisim यहां स्थित Java Runtime Package का उपयोग करता है। आपको इसे डाउनलोड करने के लिए कहा जा सकता है।
2. BYOC-I-Full.cir" - नीचे लॉजिसिम सर्किट फ़ाइल डाउनलोड करें।

Logisim लॉन्च करें फिर "फाइल-ओपन" पर क्लिक करें और BYOC-I-Full.cir फाइल लोड करें। ऊपर की छवि लॉजिसिम के काम के माहौल को दिखाती है। BYOC-I को सबसर्किट ब्लॉक द्वारा दर्शाया जाता है। बाहरी रूप से जुड़े हुए दो इनपुट हैं, रीसेट और रन, और BYOC-I के रजिस्टरों और प्रोग्राम मेमोरी के लिए हेक्साडेसिमल डिस्प्ले।

BYOC-I की प्रोग्राम मेमोरी एक साधारण प्रोग्राम के साथ प्री-लोडेड है जो A रजिस्टर में 1 से 5 तक गिना जाता है। प्रोग्राम को निष्पादित (रन) करने के लिए, इन चरणों का पालन करें।

स्टेप 1 - पोक टूल पर क्लिक करें। कर्सर को पोकिंग "उंगली" में बदलना चाहिए। चरण 2 - रीसेट इनपुट को दो बार पोक करें, एक बार इसे "1" में बदलने के लिए और फिर से इसे "0" में बदलने के लिए। यह BYOC-I को 0 पते पर प्रोग्राम शुरू करने के लिए रीसेट करता है। चरण 3 - इसे "1" में बदलने के लिए एक बार रन इनपुट को पोक करें। ए रजिस्टर को 1 से 5 तक की गिनती फिर दोहराते हुए दिखाना चाहिए। चरण 4 - यदि प्रोग्राम निष्पादित नहीं होता है, तो कंट्रोल-के दबाएं और इसे शुरू करना चाहिए।

यदि आप Logisim की क्षमताओं का पता लगाना चाहते हैं, तो मेनू बार में सहायता लिंक पर क्लिक करें। वहां से, आप Logisim "ट्यूटोरियल", "यूजर गाइड" और "लाइब्रेरी रेफरेंस" को एक्सप्लोर कर सकते हैं। एक उत्कृष्ट वीडियो परिचय यहां पाया जाता है।

चरण 2: मशीनी भाषा पदानुक्रम और कोड

BYOC-I कंप्यूटर मशीनी भाषा में लिखे गए प्रोग्राम के आधार पर कार्य करता है। BYOC-I कार्यक्रम, बदले में, एक अच्छी तरह से परिभाषित अनुक्रम में निष्पादित निर्देशों से बने होते हैं। प्रत्येक निर्देश निश्चित लंबाई के कोड से बना होता है जो BYOC-I के विभिन्न परिचालन घटकों का प्रतिनिधित्व करता है। अंत में, इन कोडों में 1s और 0s के तार होते हैं जो मशीनी भाषा का निर्माण करते हैं जिसे BYOC-I वास्तव में निष्पादित करता है।

स्पष्टीकरण के रूप में, हम कोड के साथ शुरू करेंगे और कार्यक्रम स्तर तक अपने तरीके से काम करेंगे। फिर हम एक साधारण प्रोग्राम को कोड करेंगे, इसे BYOC-I की मेमोरी में लोड करेंगे, और इसे निष्पादित करेंगे।

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

बाइनरी - हेक्साडेसिमल - दशमलव0000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000D 141110 0x000F 15

एक कोड की चौड़ाई निर्धारित करती है कि कितनी वस्तुओं का प्रतिनिधित्व किया जा सकता है। जैसा कि बताया गया है, ऊपर दिया गया 4-बिट चौड़ा कोड 16 आइटम (0 से 15) तक का प्रतिनिधित्व कर सकता है; यानी, 2 गुणा 2 को चार गुना या 2 से चौथी घात 16 के बराबर होती है। सामान्य तौर पर, प्रतिनिधित्व योग्य वस्तुओं की संख्या 2 को nवें घात तक बढ़ा दिया जाता है। यहाँ n-बिट कोड क्षमता की एक छोटी सूची है।

n - मदों की संख्या1 22 43 84 165 326 647 1288 256

BYOC-I कंप्यूटर कोड चौड़ाई को कोड द्वारा प्रदर्शित की जाने वाली वस्तुओं की संख्या को समायोजित करने के लिए चुना जाता है। उदाहरण के लिए, चार निर्देश प्रकार हैं, इसलिए 2-बिट चौड़ा कोड उपयुक्त है। प्रत्येक के संक्षिप्त विवरण के साथ BYOC-I कोड यहां दिए गए हैं।

निर्देश प्रकार कोड (tt) चार निर्देश प्रकार हैं: (1) MVI - तत्काल 8-बिट स्थिर मान को मेमोरी रजिस्टर में ले जाएं। मेमोरी रजिस्टर एक उपकरण है जो गणना के लिए उपयोग किए जाने वाले डेटा को रखता है, (2) एमओवी - डेटा को एक रजिस्टर से दूसरे रजिस्टर में ले जाएं, (3) आरआरसी - रजिस्टर-टू-रजिस्टर गणना करें, और (4) जेएमपी - जंप अगले निर्देश पर जारी रखने के बजाय एक अलग निर्देश के लिए। अपनाए गए BYOC-I निर्देश प्रकार कोड इस प्रकार हैं:

00 MVI01 MOV10 RRC11 JMP

रजिस्टर कोड (dd और ss) BYOC-I में चार 8-बिट रजिस्टर हैं जो 0 से 255 तक मानों को संग्रहीत करने में सक्षम हैं। एक 2-बिट कोड चार रजिस्टरों को नामित करने के लिए पर्याप्त है:

00 एफ रजिस्टर01 ई रजिस्टर10 डी रजिस्टर11 ए रजिस्टर

गणना कोड (सीसीसी) BYOC-I चार अंकगणित/तर्क संचालन का समर्थन करता है। भविष्य में आठ गणनाओं के विस्तार की अनुमति देने के लिए, एक 3-बिट कोड का उपयोग किया जाता है:

000 जोड़ें, निर्दिष्ट रजिस्टरों में दो 8-बिट मान जोड़ें और परिणाम को रजिस्टरों में से एक में स्टोर करें 001 एसयूबी, नामित रजिस्टरों में दो 8-बिट मान घटाएं और परिणाम को रजिस्टरों में से एक में स्टोर करें 010 - 011 भविष्य के उपयोग के लिए आरक्षित 100 और, तार्किक रूप से और नामित रजिस्टरों में दो 8-बिट मान और परिणाम को रजिस्टरों में से एक में संग्रहीत करें101 या, तार्किक रूप से या दो 8-बिट मान निर्दिष्ट रजिस्टरों में और परिणाम को रजिस्टरों में से एक में संग्रहीत करें 110 से 111, भविष्य के उपयोग के लिए आरक्षित

जंप कोड (जे) एक 1-बिट कोड जो इंगित करता है कि कूद बिना शर्त (जे = 1) है या शून्य गणना परिणाम (जे = 0) पर सशर्त नहीं है।

डेटा/पता कोड (v…v)/(a…a) ००००००००० से ११११११११ या ० से २५५ दशमलव तक के मानों का प्रतिनिधित्व करने वाले कुछ निर्देशों में 8-बिट डेटा शामिल किया जा सकता है। यह डेटा BYOC-I के 8-बिट रजिस्टरों में भंडारण के लिए 8-बिट चौड़ा है। दशमलव अंकगणित के साथ, हम अग्रणी शून्य नहीं दिखाते हैं। कंप्यूटर अंकगणित के साथ, हम अग्रणी शून्य दिखाते हैं लेकिन वे मूल्य को प्रभावित नहीं करते हैं। 00000101 संख्यात्मक रूप से 101 या 5 दशमलव के समान है।

सुझाए गए संदर्भ

बाइनरी नोटेशन - https://learn.sparkfun.com/tutorials/binaryHexadecimal नोटेशन -

आगे की पढाई

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

चरण 3: BYOC-I निर्देशों का एनाटॉमी

BYOC-I के कोड को देखते हुए, हम अगले स्तर तक जाते हैं, निर्देश। BYOC-I के लिए एक निर्देश बनाने के लिए, हम कोड को निर्दिष्ट क्रम में और निर्देश के भीतर विशिष्ट स्थानों में एक साथ रखते हैं। सभी निर्देशों में सभी कोड प्रकट नहीं होते हैं, लेकिन जब वे करते हैं, तो वे एक विशिष्ट स्थान पर होते हैं।

एमवीआई निर्देश प्रकार के लिए सबसे अधिक बिट्स की आवश्यकता होती है, कुल मिलाकर 12। निर्देश शब्द को लंबाई में 12 बिट बनाकर, हम सभी निर्देशों को समायोजित करते हैं। अप्रयुक्त (तथाकथित "डोन्ट केयर") बिट्स को मान 0 दिया जाता है। यहाँ BYOC-I निर्देश सेट है।

1. तत्काल (एमवीआई) - 00 डीडी vvvvvvvvv फ़ंक्शन को स्थानांतरित करें: 8-बिट डेटा मान V = vvvvvvvv को गंतव्य रजिस्टर dd पर ले जाएं। निष्पादन के बाद, रजिस्टर dd का मान vvvvvvvv होगा। संक्षिप्त नाम: एमवीआई आर, वी जहां आर ए, डी, ई, या एफ है। उदाहरण: 00 10 00000101 - एमवीआई डी, 5 - मान 5 को डी रजिस्टर में ले जाएं।
2. रजिस्टर टू रजिस्टर (MOV) - 01 dd ss 000000Function: डेटा को सोर्स रजिस्टर ss से डेसिनेशन रजिस्टर dd में ले जाएँ। निष्पादन के बाद, दोनों रजिस्टरों का स्रोत रजिस्टर के समान मूल्य होता है। संक्षिप्त नाम: एमओवी आरडी, रुपये जहां आरडी गंतव्य रजिस्टर ए, डी, ई, या एफ है और रुपये स्रोत रजिस्टर ए, डी, ई, या एफ है। उदाहरण: 01 11 01 000000 - एमओवी ए, ई - मान को स्थानांतरित करें रजिस्टर ई में रजिस्टर करने के लिए ए।
3. रजिस्टर टू रजिस्टर कैलकुलेशन (RRC) - 10 dd ss ccc 000Function: सोर्स रजिस्टर ss और डेस्टिनेशन रजिस्टर dd का उपयोग करके निर्दिष्ट गणना ccc करें और फिर परिणाम को डेस्टिनेशन रजिस्टर में स्टोर करें। संक्षेप: ADD Rd, रुपये (ccc = 000 Rd + रुपये में संग्रहीत) आरडी); उप आरडी, रुपये (सीसीसी = 001 आरडी - आरडी में संग्रहीत रुपये); और आरडी, रुपये (सीसीसी = 100 आरडी और आरडी में संग्रहीत रुपये); या आरडी, रुपये (सीसीसी = 101 आरडी या आरडी में संग्रहीत रुपये)। उदाहरण: 10 00 11 001 000 - उप एफ, ए - एफ रजिस्टर में परिणाम के साथ एफ रजिस्टर से ए रजिस्टर में मूल्य घटाएं।
4. अलग-अलग निर्देश (जेएमपी) पर जाएं - 11 जे 0 आआआआआआआआआआआआआआआआआआआआआआआआआआ (ए) पते पर स्थित एक अलग निर्देश में निष्पादन बदलें (जे = 1) -11 1 0 आआआआ संक्षिप्त नाम: जेएमपी एल जहां एल पता आआ आआआ उदाहरण: 11 1 0 00001000 - जेएमपी 8 - निष्पादन को पते में बदलें 8.(बी) सशर्त (जे = 0) जब पिछली गणना के परिणामस्वरूप शून्य परिणाम नहीं हुआ - 11 0 0 आआआआआ संक्षिप्त नाम: जेएनजेड एल जहां एल पता आआ आआआ है। उदाहरण: 11 0 0 00000100 JNZ 4 यदि अंतिम गणना में एक गैर-शून्य मान प्राप्त होता है, तो निष्पादन को पता 4 में बदलें।

निर्देश शब्द बिट्स को 11 से 0 तक बाएं (सबसे महत्वपूर्ण बिट एमएसबी) से दाएं (कम से कम महत्वपूर्ण बिट एलएसबी) क्रमांकित किया जाता है। कोड के निश्चित क्रम और स्थान निम्नानुसार हैं:

बिट्स - कोड11-10 निर्देश प्रकार9-8 गंतव्य रजिस्टर7-6 स्रोत रजिस्टर5-3 गणना: 000 - जोड़ें; 001 - घटाना; 100 - तार्किक और; १०१ - तार्किक OR7-0 निरंतर मान v…v और a…a (0 से 255)

निर्देश सेट को ऊपर दिए गए चित्र में संक्षेपित किया गया है। प्रत्येक निर्देश में कोड की संरचित और व्यवस्थित उपस्थिति पर ध्यान दें। परिणाम BYOC-I के लिए एक सरल डिजाइन है और यह मानव के लिए निर्देशों को समझना आसान बनाता है।

चरण 4: एक कंप्यूटर निर्देश कोडिंग

कार्यक्रम स्तर पर जाने से पहले, आइए ऊपर दिए गए BYOC-I निर्देश सेट का उपयोग करके कुछ उदाहरण निर्देशों का निर्माण करें।

1. रजिस्टर ए के लिए मान 1 को स्थानांतरित करें। बीओओसी-आई रजिस्टर 0 से 255 तक मूल्यों को स्टोर कर सकते हैं। इस मामले में, रजिस्टर ए में निर्देश के निष्पादन के बाद मान 1 (00000001 बाइनरी) होगा।

संक्षिप्त नाम: एमवीआई ए, 1 आवश्यक कोड: एमवीआई - 00 टाइप करें; गंतव्य रजिस्टर ए - 11; मान - 00000001निर्देश शब्द: 00 11 00000001

2. रजिस्टर ए की सामग्री को डी रजिस्टर करने के लिए ले जाएं। निष्पादन के बाद, दोनों रजिस्टरों का मूल रूप से रजिस्टर ए में मूल्य होगा।

संक्षिप्त नाम: MOV D, A (याद रखें, सूची में गंतव्य पहले और स्रोत दूसरे स्थान पर है) आवश्यक कोड: MOV - 01 टाइप करें; गंतव्य रजिस्टर डी - 10; स्रोत रजिस्टर ए - 11निर्देश शब्द: 01 10 11 000000

3. रजिस्टर ए में रजिस्टर डी की सामग्री जोड़ें और रजिस्टर ए में स्टोर करें। निष्पादन के बाद, रजिस्टर ए का मूल्य रजिस्टर ए और रजिस्टर डी के मूल मूल्य का योग होगा।

संक्षिप्त नाम: ए, डी जोड़ें (परिणाम गंतव्य रजिस्टर में संग्रहीत है) आवश्यक कोड: टाइप आरआरसी - 10; गंतव्य रजिस्टर ए - 11; स्रोत रजिस्टर डी - 10; गणना जोड़ें - 000निर्देश शब्द: 10 11 10 000 000 (सीसीसी पहले 000 है - जोड़ें)

4. नॉट ज़ीरो टू एड्रेस 3. यदि अंतिम गणना का परिणाम शून्य नहीं था, तो निष्पादन दिए गए पते पर निर्देश में बदल जाएगा। यदि शून्य है, तो निष्पादन निम्नलिखित निर्देश पर फिर से शुरू होता है।

संक्षिप्त नाम: जेएनजेड 3 आवश्यक कोड: जेएमपी - 11 टाइप करें; कूद प्रकार - 0; पता - 00000003निर्देश शब्द: ११ ० ००००००००३ (कूद प्रकार पहले ० है)

5. बिना शर्त 0 पते पर जाएं। निष्पादन के बाद, निष्पादन दिए गए पते पर निर्देश में बदल जाता है।

संक्षिप्त नाम: जेएमपी 0 कोड आवश्यक: जेएमपी - 11 टाइप करें; जंप टाइप - 1; पता - 00000000निर्देश शब्द; ११ १ ० ००००००००

जबकि मशीन कोडिंग कुछ कठिन है, आप देख सकते हैं कि यह असंभव रूप से कठिन नहीं है। यदि आप वास्तविक के लिए मशीन कोडिंग कर रहे थे, तो आप संक्षिप्त नाम (जिसे असेंबली कोड कहा जाता है) से मशीन कोड में अनुवाद करने के लिए एक असेंबलर नामक कंप्यूटर प्रोग्राम का उपयोग करेंगे।

चरण 5: एक कंप्यूटर प्रोग्राम का एनाटॉमी

एक कंप्यूटर प्रोग्राम निर्देशों की एक सूची है जिसे कंप्यूटर सूची की शुरुआत से सूची के अंत तक जारी रखता है। जेएनजेड और जेएमपी जैसे निर्देश बदल सकते हैं कि कौन सा निर्देश आगे निष्पादित किया गया है। सूची में प्रत्येक निर्देश 0 से शुरू होने वाले कंप्यूटर की मेमोरी में एक ही पता रखता है। BYOC-I मेमोरी में 256 निर्देशों की सूची हो सकती है, जो हमारे उद्देश्यों के लिए पर्याप्त से अधिक है।

कंप्यूटर प्रोग्राम किसी दिए गए कार्य को करने के लिए डिज़ाइन किए गए हैं। हमारे कार्यक्रम के लिए, हम 1 से 5 तक गिनती करते हुए एक सरल कार्य का चयन करेंगे। जाहिर है, कोई "गिनती" निर्देश नहीं है, इसलिए पहला कदम कार्य को चरणों में तोड़ना है जिसे BYOC-I द्वारा नियंत्रित किया जा सकता है। सीमित निर्देश सेट।

चरण 1 पंजीकरण करने के लिए 1 को स्थानांतरित करें चरण 2 पंजीकरण करने के लिए रजिस्टर ए को स्थानांतरित करें डीचरण 3 रजिस्टर ए में रजिस्टर डी जोड़ें और परिणाम को रजिस्टर में स्टोर करें। घटाव परिणाम शून्य नहीं था, चरण 4 पर वापस जाएं और गिनना जारी रखेंचरण 7 यदि घटाव परिणाम शून्य था, तो वापस जाएं और फिर से शुरू करें

अगला कदम इन चरणों का BYOC-I निर्देशों में अनुवाद करना है। BYOC-I प्रोग्राम एड्रेस 0 और नंबर पर लगातार शुरू होते हैं। सभी निर्देशों के लागू होने के बाद जम्प लक्ष्य पते अंतिम जोड़े जाते हैं।

पता: निर्देश - संक्षिप्त नाम; विवरण: ००० ११ ००००००१ - एमवीआई ए, १; ए १:०१ १० ११ ०००० - एमओवी डी, ए; रजिस्टर करने के लिए १ को स्थानांतरित करें; डी २:१० ११ १० ०००००० - एडीडी ए, डी रजिस्टर ए में रजिस्टर डी जोड़ें और परिणाम को रजिस्टर ए 3:00 01 00 00000101 - एमवीआई ई, 5 में स्टोर करें; 5 रजिस्टर ई 4:10 01 11 001 000 - एसयूबी ई, ए को स्थानांतरित करें; रजिस्टर ई से रजिस्टर ए घटाएं और स्टोर करें रजिस्टर में परिणाम E5:11 0 0 00000010 - JNZ 2; यदि घटाव परिणाम शून्य नहीं था, तो पता 3 पर वापस जाएं और गिनती जारी रखें6:11 1 0 00000000 - JMP 0; यदि घटाव परिणाम शून्य था, तो वापस जाएं और शुरू करें

प्रोग्राम को मेमोरी में स्थानांतरित करने से पहले, बाइनरी निर्देश कोड को लॉजिकिम हेक्स संपादक के साथ उपयोग करने के लिए हेक्साडेसिमल में बदलना होगा। सबसे पहले, निर्देश को 4 बिट्स के तीन समूहों में विभाजित करें। फिर चरण 2 में तालिका का उपयोग करके समूहों को हेक्साडेसिमल में अनुवाद करें। केवल अंतिम तीन हेक्साडेसिमल अंक (नीचे बोल्ड में) का उपयोग किया जाएगा।

पता - निर्देश बाइनरी - निर्देश बाइनरी स्प्लिट - निर्देश (हेक्स) 0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 111000000010 1110 0000 0000 - 0x0E00

परीक्षण के लिए कार्यक्रम को BYOC-I की मेमोरी में स्थानांतरित करने का समय आ गया है।

चरण 6: प्रोग्राम को मेमोरी और टेस्टिंग में स्थानांतरित करना

Logisim "मुख्य" सर्किट को देखते हुए, दिखाया गया BYOC-I ब्लॉक एक्सप्लोरर फलक में "BYOC-I" लेबल वाले वास्तविक कंप्यूटर सर्किट का प्रतीक है। BYOC-I मेमोरी में प्रोग्राम दर्ज करने के लिए:

1. BYOC-I ब्लॉक (जिसे "सब-सर्किट" कहा जाता है) पर राइट क्लिक करें और चुनें (ऊपर होवर करें और बायाँ क्लिक करें) "देखें BYOC-I"।
2. BYOC-I सर्किट कार्य क्षेत्र में दिखाई देगा। "प्रोग्राम मेमोरी" प्रतीक पर राइट क्लिक करें और "सामग्री संपादित करें.." चुनें।
3. Logisim Hex Editor का उपयोग करते हुए, ऊपर दिखाए गए अनुसार हेक्साडेसिमल कोड (केवल बोल्ड) दर्ज करें।

अब आप प्रोग्राम को निष्पादित करने के लिए तैयार हैं। एक्सप्लोरर फलक में "BYOC-I" पर डबल क्लिक करके मुख्य सर्किट पर लौटें। प्रारंभ करने के लिए रन और रीसेट इनपुट "0" होना चाहिए। पोक टूल का उपयोग करके, पहले रीसेट को "1" में बदलें और फिर वापस "0" में बदलें। यह प्रारंभिक पता 0x0000 बनाता है और निष्पादन के लिए BYOC-I सर्किट तैयार करता है। अब रन इनपुट को "1" पर पोक करें और प्रोग्राम निष्पादित हो जाएगा। (नोट: Logisim घड़ी शुरू करने के लिए आपको मुख्य रूप से Control-K को एक बार टैप करना होगा। यह एक ऐसी सुविधा है जो आपको Logisim घड़ी को रोकने और प्रोग्राम के माध्यम से बार-बार Control-T को टैप करने की अनुमति देती है। इसे कभी-कभी आज़माएं!)

Logisim घड़ी आवृत्तियों की एक विस्तृत श्रृंखला के लिए व्यवस्थित है। डाउनलोड के रूप में यह 8 हर्ट्ज (प्रति सेकंड 8 चक्र) है। जिस तरह से BYOC-I कंप्यूटर को डिज़ाइन किया गया है, प्रत्येक निर्देश को पूरा होने में चार घड़ी चक्र लगते हैं। तो, BYOC-I गति की गणना करने के लिए, घड़ी की आवृत्ति को 4 से विभाजित करें। 8 हर्ट्ज पर, इसकी गति 2 निर्देश प्रति सेकंड है। आप टूल बार पर "सिमुलेट" पर क्लिक करके और "टिक फ़्रीक्वेंसी" का चयन करके घड़ी बदल सकते हैं। संभावित सीमा 0.25 हर्ट्ज से 4100 हर्ट्ज तक है। 8 हर्ट्ज पर धीमी गति को चुना गया ताकि आप ए रजिस्टर में गिनती देख सकें।

आधुनिक कंप्यूटरों की तुलना में BYOC-I सिमुलेशन (~1000 निर्देश प्रति सेकंड) की अधिकतम गति बहुत धीमी है। मेरी पुस्तक में वर्णित BYOC कंप्यूटर का हार्डवेयर संस्करण प्रति सेकंड 12 मिलियन से अधिक निर्देशों को निष्पादित करता है!

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

1. एक प्रोग्राम लिखें जो ५ से शुरू होता है और ० तक गिनता है। (ANS. Count5to0.txt नीचे)
2. 2 से शुरू करके, 3 से गिनें जब तक कि संख्या 7 से अधिक न हो जाए। आप थोड़ा मानसिक अंकगणित कर सकते हैं, 8 की जाँच करें यह जानते हुए कि यह वहाँ उतरेगा फिर पुनः आरंभ करें। अपने प्रोग्राम को अधिक सामान्य तरीके से लिखें जो वास्तव में परीक्षण करता है कि क्या गिनती एक विशिष्ट संख्या से "अधिक" है। संकेत: एक्सप्लोर करें कि क्या होता है जब घटाव एक नकारात्मक मान उत्पन्न करता है, उदाहरण के लिए 8 - 9 = -1। फिर तार्किक के साथ प्रयोग करें और यह जांचने के लिए कि 8-बिट संख्या में MSB "1" है या नहीं। (ANS. ExceedsCount.txt)

क्या आप BYOC-I कंप्यूटर के लिए अन्य चुनौतीपूर्ण समस्याओं के बारे में सोच सकते हैं? इसकी सीमाओं को देखते हुए, यह और क्या कर सकता है? अपने अनुभव मेरे साथ [email protected] पर साझा करें। यदि आप माइक्रोप्रोसेसरों की कोडिंग में रुचि रखते हैं, तो मेरी वेबसाइट www.whippleway.com देखें।वहां मैं आधुनिक प्रोसेसर के लिए मशीन कोडिंग करता हूं जैसे कि Arduinos में उपयोग की जाने वाली ATMEL मेगा श्रृंखला।