👨🏾‍💻 🚪 👵🏾 गेमबॉय एमुलेटर लिखना, भाग 1 🚵🏿 🤲🏾 🏴󠁧󠁢󠁷󠁬󠁳󠁿

आपका स्वागत है!

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

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

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

इस लेख में, हम गेमबॉय को जानेंगे और इसके प्रोसेसर और मेमोरी का अनुकरण करके शुरू करेंगे।

गेमबॉय एमुलेटर लिखना, भाग 1
गेमबॉय एमुलेटर लिखना, भाग 2
एक गेमबॉय एमुलेटर लिखना, भाग 3

सामग्री की तालिका

परिचय
आर्किटेक्चर
प्रोसेसर
बीच में आता है
स्मृति
निष्कर्ष

परिचय

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

शुरू करने से पहले, आपको खुद को DMG की तकनीकी विशेषताओं से परिचित करना होगा:

प्रोसेसर	8-बिट शार्प LR35902 4.19 मेगाहर्ट्ज की आवृत्ति पर काम कर रहा है
बिना सोचे समझे याद करना	8 केबी
वीडियो मेमोरी	8 केबी
स्क्रीन रिज़ॉल्यूशन	160x144
लंबवत आवृत्ति	59.73 हर्ट्ज
ध्वनि	4 चैनल, स्टीरियो साउंड

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

DMG के लिए एक शानदार दस्तावेज है जिसे गेमबॉय सीपीयू मैनुअल कहा जाता है। इसमें प्रख्यात डेवलपर्स के कई प्रसिद्ध दस्तावेज शामिल हैं और इसमें लगभग सभी जानकारी शामिल है जिनकी हमें आवश्यकता है। स्वाभाविक रूप से, यह सब नहीं है, लेकिन इस स्तर पर यह पर्याप्त से अधिक है।

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

चूंकि लेख मेरे एमुलेटर पर एक आंख से लिखे गए थे, इसलिए यहां कुकी स्रोत और कुकी कुकी का लिंक है।

आर्किटेक्चर

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

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

तो चलिए शुरू करते हैं।

प्रोसेसर

DMG में 4194304 हर्ट्ज की आवृत्ति पर चलने वाला 8-बिट शार्प LR35902 प्रोसेसर है (ऐसी सटीकता पर आश्चर्य न करें - हमें भविष्य में इस नंबर की आवश्यकता होगी)। इसे ज़िलॉग ज़ेड 80 प्रोसेसर का सरलीकृत संस्करण माना जा सकता है, जो बदले में इंटेल 8080 पर आधारित है। ज़ेड 80 की तुलना में, कुछ रजिस्टर और इंस्ट्रक्शन सेट गायब हैं।

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

बिट	7	6	5	4	3	2	1	0
झंडा	जेड	एन	एच	सी	0	0	0	0

झंडे का उद्देश्य:

शून्य ध्वज (Z) - ध्वज सेट किया गया है (बिट 1 है) यदि पिछले गणितीय ऑपरेशन का परिणाम शून्य है या तुलना करने पर दो ऑपरेंड समान हो गए हैं।
सबस्ट्रैक्ट फ्लैग (N) - ध्वज को सेट किया जाता है यदि अंतिम ऑपरेशन एक घटाव था।
हाफ कैरी फ़्लैग (H) - फ़्लैग सेट किया गया है, यदि पिछले गणितीय ऑपरेशन के परिणामस्वरूप, निचले आधे बाइट से एक स्थानांतरण हुआ है।
कैरी फ्लैग (C) - ध्वज को तब सेट किया जाता है जब अंतिम गणितीय ऑपरेशन के परिणामस्वरूप स्थानांतरण हुआ हो।

रजिस्टर पीसी (प्रोग्राम काउंटर), जैसा कि आप अनुमान लगा सकते हैं, एक निर्देश काउंटर है और इसमें अगले निर्देश का पता है।

क्रमशः एसपी रजिस्टर (स्टैक पॉइंटर), स्टैक के शीर्ष पर एक पॉइंटर है। जो लोग जानते नहीं हैं, उनके लिए स्टैक एक मेमोरी क्षेत्र है जिसमें वेरिएबल्स, रिटर्न एड्रेस आदि के मान लिखे जाते हैं। एसपी में स्टैक के शीर्ष का पता होता है - स्टैक नीचे से उच्च तक बढ़ता है। उसके लिए, हमेशा कम से कम दो ऑपरेशन होते हैं। PUSH आपको एक निश्चित मान सम्मिलित करने की अनुमति देता है - पहले, SP रजिस्टर कम हो जाता है, और फिर एक नया मान डाला जाता है। पीओपी आपको मूल्य को पुनः प्राप्त करने की अनुमति देता है - पहले, पते पर एसपी, मान को मेमोरी से पुनर्प्राप्त किया जाता है, और फिर एसपी को बढ़ाया जाता है।

प्रोसेसर में तथाकथित IME (इंटरप्ट मास्टर सक्षम) भी शामिल है - एक झंडा जो बाधित प्रसंस्करण की अनुमति देता है। यह क्रमशः दो मान लेता है - अक्षम (0) और सक्षम (1)।

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

union WordRegister { struct { BYTE L; BYTE H; } bytes; WORD word; };

हम प्रोसेसर रजिस्टरों को जोड़े के रूप में संग्रहीत करेंगे, और हमारे पास WordRegister एसोसिएशन के लिए व्यक्तिगत भागों तक पहुंच होगी। शब्द क्षेत्र पूरे 16-बिट रजिस्टर तक पहुंच देगा। "बाइट्स" फ़ील्ड एक जोड़े में व्यक्तिगत रजिस्टरों तक पहुंच प्रदान करता है। केवल एक चीज यह है कि ए और एफ को अलग-अलग संग्रहीत किया जाना चाहिए। रजिस्टर ए एक बैटरी है, जिसका अर्थ है कि इसका उपयोग अक्सर किया जाता है। रजिस्टर एफ प्रोसेसर झंडे के साथ एक समान स्थिति काफी बार सेट की जानी है।

अब प्रोसेसर को स्वयं लागू करना शुरू करें - कुकीबॉय :: सीपीयू वर्ग इसके लिए जिम्मेदार होगा। निर्देशों को पढ़ना और निष्पादित करना सामान्य तरीके से लागू किया जाएगा - मेमोरी से एक ओपोड पढ़ना, और फिर स्विच निर्माण का उपयोग करके डिकोडिंग और निष्पादन:

 BYTE opcode = MMC.Read(PC); PC++; switch (opcode) { case 0x00: break; }

सभी ऑपकोड की लंबाई 1 बाइट है, लेकिन कुछ निर्देश तथाकथित उपसर्ग का उपयोग करते हैं - पहला बाइट निर्देश सेट का उपसर्ग है (हमारे लिए, एकमात्र उपसर्ग 0xCB है), दूसरा बाइट इस सेट से ओपकोड है। कार्यान्वयन प्राथमिक है - जैसे ही हम 0xCB पर ठोकर खाई, हम एक और बाइट पढ़ते हैं और इसे एक नेक्ड स्विच के साथ डिकोड करते हैं।

यह कोड शून्य चरण () फ़ंक्शन में रखा गया है, जो एक कॉल में एक प्रोसेसर निर्देश को निष्पादित करता है और अन्य आवश्यक संचालन करता है।

स्वाभाविक रूप से, स्मृति को पढ़ने और लिखने के लिए, हमें एक और वर्ग की आवश्यकता है - कुकीबॉय :: मेमोरी, जिसकी वस्तु को "एमएमसी" नाम से ऊपर देखा जा सकता है। इस स्तर पर, बुनियादी विधियों के साथ स्टब्स पर्याप्त हैं:

 class Memory { public: void Write(WORD addr, BYTE value); BYTE Read(WORD addr); };

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

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

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

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

इस मामले में, निष्पादन प्रक्रिया में कई बार सिंक्रनाइज़ेशन मैक्रो का उपयोग करना आवश्यक है, ताकि पढ़ने या लिखने के समय सही डेटा मेमोरी में हो। अधिकांश निर्देशों में इस तरह के सटीक सिंक्रनाइज़ेशन की आवश्यकता नहीं होती है, और इसे निष्पादन के बाद निष्पादित करने की अनुमति होती है। दूसरों को सिंक्रनाइज़ेशन फ़ंक्शन और मेमोरी रीड / राइट ऑपरेशन के सटीक अनुक्रम की आवश्यकता होती है।

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

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

किसी भी प्रोसेसर निर्देश की एक विशिष्ट अवधि होती है, जिसे हम एक मशीन चक्र कहते हैं। एक मशीन चक्र में, प्रोसेसर एक से एक कार्रवाई कर सकता है, जैसे कि एक ओपकोड पढ़ना, इसे डिकोड करना और एक कमांड निष्पादित करना; स्मृति में पढ़ना या लिखना। बदले में, एक मशीन चक्र में मशीन चक्र शामिल होते हैं, क्योंकि एक प्रोसेसर एक मशीन चक्र में कई ऑपरेशन कर सकता है। और इसलिए हम अपने प्रोसेसर पर आते हैं। अगर हम कहते हैं कि एनओपी 4 चक्रों तक रहता है, तो हम मशीन चक्रों के बारे में बात कर रहे हैं। अगर हम एनओपी के लिए 1 घड़ी चक्र के बारे में बात कर रहे हैं, तो हम मशीन चक्रों के बारे में बात कर रहे हैं। यह ठीक उसी प्रकार है जैसे DMG प्रोसेसर काम करता है - इसका मशीन चक्र 4 मशीन चक्र तक रहता है और कई निर्देशों में ठीक 4 चक्र या 1 मशीन चक्र होता है - DMG प्रोसेसर मेमोरी से ओपकोड को पढ़ने में सक्षम होता है, इसे डिकोड करता है और केवल 4 मशीन चक्र में निर्देश को निष्पादित करता है।

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

इस स्तर पर, सभी प्रोसेसर निर्देशों का पूरी तरह से अनुकरण करना पहले से ही संभव है। अलग से, यह उनमें से कुछ का उल्लेख करने योग्य है:

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

इन कमियों के अलावा, अन्य हैं। CPU मैनुअल में निर्देशों की अवधि का अधूरा विवरण होता है। जैसा कि आप अनुमान लगा सकते हैं, सशर्त शाखा निर्देशों में अलग-अलग अवधि होनी चाहिए, जो इस बात पर निर्भर करती है कि शाखा हुई है या नहीं। परीक्षण रोम का उपयोग करना संभव होगा, लेकिन इन निर्देशों के कारण वे अपने आप सही ढंग से काम नहीं करते हैं, इसलिए वे परीक्षण शुरू किए बिना भी एक अज्ञात त्रुटि प्रदर्शित करते हैं। यहां इन निर्देशों की एक तालिका दी गई है, जो उनकी अवधि को दर्शाती है:

opcodes	संक्रमण नहीं हुआ	संक्रमण हुआ है
0xC2, 0xCA, 0xD2, 0xDA	12	16
0x20, 0x28, 0x30, 0x38	8	12
0xC4, 0xCC, 0xD4, 0xDC	12	24
0xC0, 0xC8, 0xD0, 0xD8	8	20

इसके अलावा निर्देश के लिए RST n (opcodes 0xC7, 0xCF, 0xD7, 0xDF, 0xE7, 0xEF, 0xF7, 0xFF) गलत अवधि इंगित करता है। सही मान 16 उपाय है।

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

बीच में आता है

इंटरप्ट एक ऐसी घटना है जो वर्तमान प्रोसेसर निर्देशों के निष्पादन को रोकती है और नियंत्रण हैंडलर को ट्रांसफर करती है। डीएमजी इस सिद्धांत पर काम करता है।

सिंक्रनाइज़ेशन के दौरान, हम एमुलेटर के अन्य घटकों के सिंक्रनाइज़ेशन तरीकों को कहते हैं, जो एक बाधा का अनुरोध कर सकते हैं। DMG में, यह निम्नानुसार किया जाता है। दो रजिस्टर हैं (जहां वे स्थित हैं, बाद में चर्चा की जाएगी) - आईएफ (बीच में झंडे) और आईई (बाधा सक्षम)। उनके बिट्स का एक विशिष्ट उद्देश्य है, जो दोनों रजिस्टरों में समान है:

बिट	व्यवधान
4	joypad
3	सीरियल I / O स्थानांतरण पूर्ण
2	अधिक समय तक बहना
1	LCDC
0	वि रिक्त

IF रजिस्टर बिट्स संकेत करते हैं कि कौन से व्यवधान का अनुरोध किया गया था। यदि बिट सेट है, तो एक बाधा का अनुरोध किया जाता है।

IE रजिस्टर बिट्स इंटरप्ट हैंडलिंग को सक्षम करते हैं। यदि बिट को एक पर सेट किया गया है और संबंधित बाधा का अनुरोध किया गया है, तो इसे संसाधित किया जाएगा। यदि नहीं, तो व्यवधान पर कार्रवाई नहीं की जाएगी।

जैसा कि आप देख सकते हैं, बिट्स का समान असाइनमेंट बहुत उपयोगी है और आपको तार्किक ऑपरेशन का उपयोग करने की अनुमति देता है और यह पता लगाने के लिए कि किस व्यवधान को संसाधित किया जाना चाहिए।

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

जांचें कि क्या कोई व्यवधान है जो प्रसंस्करण के लायक है। यह IE और IF रजिस्टरों के बीच तार्किक और संचालन का उपयोग करके किया जाता है। इसके अतिरिक्त, यह संभव कचरा निकालने के लिए परिणाम और संख्या 0x1F के साथ एक तार्किक और ऑपरेशन करने के लायक है, क्योंकि दोनों रजिस्टरों में सबसे महत्वपूर्ण तीन बिट्स का उपयोग नहीं किया जाता है।
यदि ऐसी कोई रुकावट नहीं हैं, तो हम फ़ंक्शन से बाहर निकलते हैं। यदि वे हैं, तो अभी हमें प्रोसेसर को शटडाउन स्थिति से बाहर लाना होगा।
अब हम बीच-बीच में प्रक्रिया शुरू कर रहे हैं। ऐसा करने के लिए, हम जाँचते हैं कि क्या IME ध्वज उनके प्रसंस्करण को प्रतिबंधित करता है। यदि नहीं, तो:
1. शून्य IME;
2. स्टैक पर पीसी रजिस्टर लोड करें;
3. हम मेमोरी में हैंडलर के पते पर पीसी रजिस्टर सेट करके इंटरप्ट हैंडलर कहते हैं;
4. संसाधित व्यवधान के लिए IF रजिस्टर बिट सेट करें।

व्यवधानों को एक बार में और एक सख्ती से परिभाषित क्रम में संसाधित किया जाता है। हैंडलर की प्राथमिकताओं और पते के बारे में सभी जानकारी सीपीयू मैनुअल में इंगित की गई है।

एक महत्वपूर्ण विवरण। फिर, किसी ने सोचा हो सकता है: एक प्रक्रिया को कॉल करना एक प्रक्रिया को कॉल करने के समान है, और इसलिए कुछ समय लेना चाहिए। यह सच है और इसमें 20 उपाय हैं। किसी कारण से, यह बिंदु DMG का वर्णन करने वाले दस्तावेजों में छोड़ा गया है।

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

इंटरप्ट रिक्वेस्ट के बारे में थोड़ा। यह IF रजिस्टर में संबंधित बिट्स सेट करके किया जाता है। स्थापना से पहले, IE केस सत्यापन की आवश्यकता नहीं है। भले ही इसमें बिट्स एक विशिष्ट रुकावट को रोकते हैं, फिर भी हम बिट्स को इस रुकावट के लिए IF रजिस्टर में सेट करते हैं।

यदि आपने कुकीबॉय के मेरे कार्यान्वयन के स्रोत कोड को देखा: रुकावट है, तो आप नोटिस कर सकते हैं कि मैं IE और IF रजिस्टरों के मूल्य को वापस कर रहा हूं क्योंकि मैंने उन सभी बिट्स को एक में सेट नहीं किया है (या मान 0-0E0 के साथ ऑपरेशन)। मैं इसे एक कारण के लिए करता हूं। I / O पोर्ट्स (उस पर अधिक) में बहुत सारे रजिस्टर सभी बिट्स का उपयोग नहीं करते हैं, दूसरों ने कुछ बिट्स या पूरे रजिस्टर तक एक ही बार में पहुंच को प्रतिबंधित कर दिया है। इसे भी ध्यान में रखा जाना चाहिए - इसके लिए, अप्रयुक्त और निषिद्ध बिट्स को पढ़ने से पहले लौटने से पहले सेट किया जाना चाहिए।

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

स्मृति

हम एक शब्द को अग्रिम रूप से परिभाषित करते हैं - एक मेमोरी बैंक। इसके द्वारा हम कड़ाई से परिभाषित आकार के एक मेमोरी क्षेत्र का मतलब है। दो प्रकार के बैंक हैं - 0x4000 बाइट की लंबाई वाले ROM बैंक, और 0x2000 की लंबाई वाले रैम बैंक (एक बार जब आप हेक्साडेसिमल नंबर सिस्टम के अभ्यस्त हो जाते हैं, तो यह मेरे और आपके लिए आसान होगा)। इसकी आवश्यकता क्यों है? DMG प्रोसेसर 16-बिट पतों के साथ काम करने में सक्षम है, जिसका अर्थ है कि पता स्थान 0x10000 बाइट्स तक सीमित है। इनमें से, केवल 0x8000 बाइट्स खेल की छवि के लिए आरक्षित हैं। ज्यादातर मामलों में, यह पर्याप्त नहीं है और मेमोरी बैंक खेलने में आते हैं।

मेमोरी बैंकों के बिना, 0x4000-0x7FFF के पते की ओर मुड़ते हुए, हम खेल की छवि में इस पते पर पहुंचेंगे। मेमोरी बैंकों का उपयोग करके, हम छवि को बैंकों में विभाजित करने के लिए सेट कर सकते हैं, और पते पर 0x4000-0x7FFF चयनित बैंक को प्रदर्शित किया जाएगा। इस प्रकार, इस क्षेत्र में एक पल में दूसरा बैंक है, दूसरे पर - दसवां। जैसा हम चाहते हैं, सामान्य तौर पर। इस प्रकार, हम आभासी और भौतिक पते पर पहुंचते हैं। 0x4000-0x7FFF वर्चुअल पते हैं जिनका भौतिक पते से मिलान नहीं है। एक भौतिक पता वास्तविक पता है जिस पर मेमोरी सेल एक्सेस किए जाते हैं।

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

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

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

स्वाभाविक रूप से, हम ROM की सामग्री को बदल नहीं सकते। MBC के लिए नियंत्रण कमांड के रूप में लिखने के संचालन का उपयोग किया जाता है। सीपीयू मैनुअल में, आप पढ़ सकते हैं कि कौन से पते किन कार्यों के लिए जिम्मेदार हैं। इस प्रकार, एक विशिष्ट पते पर 9 नंबर लिखा हुआ है, हम कहते हैं कि हम बैंक 9 का चयन करना चाहते हैं। उसके बाद, हम इसकी सामग्री को 0x4000-0x7FFF पर संपर्क करके पढ़ सकते हैं।

नीचे दिया गया आंकड़ा सबसे सरल एमबीसी ऑपरेशन योजना को दर्शाता है। यहाँ, क्षेत्र 0x0000-0x3FFF को हमेशा कुछ वास्तविक नियंत्रकों के रूप में बैंक 0 पर पुनर्निर्देशित किया जाता है, लेकिन क्षेत्र 0x4000-0x7FFF को वर्तमान बैंक में पुनर्निर्देशित किया जाता है।

DMG पता स्थान योजना पर विचार करें:

मेमोरी अनुभाग	पता शुरू करें	अंत का पता
रॉम बैंक 0	0x0000	0x3FFF
स्विच करने योग्य ROM बैंक	0x4000	0x7FFF
वीडियो राम	0x8000	0x9FFF
स्वाइप राम बैंक	0xA000	0xBFFF
आंतरिक RAM १	0xC000	0xDFFF
इंटरनल रैम 1 की गूंज	0xE000	0xFDFF
OAM	0xFE00	0xFE9F
उपयोग नहीं किया गया	0xFEA0	0xFEFF
मैं / हे बंदरगाहों	0xFF00	0xFF4B
उपयोग नहीं किया गया	0xFF4C	0xFF7F
आंतरिक RAM 2	0xFF80	0xFFFE
बाधा सक्षम रजिस्टर	0xFFFF	0xFFFF

प्रत्येक अनुभाग के बारे में अधिक जानकारी:

ROM बैंक 0. स्विचेबल ROM बैंक। इन क्षेत्रों पर हम पहले ही विचार कर चुके हैं।
वीडियो रैम। ग्राफिक्स को लागू करते समय अधिक विवरण पर विचार किया जाएगा।
इंटरनल रैम 1. डीएमजी के अंदर रैम।
आंतरिक रैम की गूंज 1. यह आंतरिक रैम 1 की सामग्री को डुप्लिकेट करता है।
OAM। यह वह जगह है जहां स्प्राइट्स का वर्णन संग्रहीत है।
मैं / हे बंदरगाहों। यहां हमें अन्य डीएमजी घटकों के रजिस्टरों तक पहुंच मिलती है।
इंटरनल रैम 2. डीएमजी के अंदर रैम।
बाधा सक्षम रजिस्टर। यह रजिस्टर उन झंडों को संग्रहीत करता है जो कुछ व्यवधानों के प्रसंस्करण को सक्षम करते हैं। यह वही IE रजिस्टर है जिसके बारे में हमने पहले ही बात की थी।

चूंकि एमुलेटर का आर्किटेक्चर मानता है कि प्रत्येक डीएमजी घटक का अपना वर्ग होगा, कुकीबॉय :: मेमोरी क्लास, जो मेमोरी का अनुकरण करता है, इसमें केवल निम्नलिखित मेमोरी क्षेत्र शामिल होंगे - ROM बैंक, आंतरिक रैम 1, इको की आंतरिक रैम 1, स्वैचेबल रैम बैंक, आंतरिक रैम 2. जब अन्य सभी क्षेत्रों में प्रवेश करते हैं, तो संबंधित वर्गों की पहुंच विधियों को बुलाया जाएगा।

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

 switch (addr & 0xF000) { case 0x8000: case 0x9000: //    break; }

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

यदि जिस कारतूस से ROM को हटाया गया था, उसमें MBC नियंत्रक था, तो इन मेमोरी क्षेत्रों में हमें इन नियंत्रकों के तर्क को लागू करने की आवश्यकता है। आप इसे बहुत ही सरलता से कर सकते हैं - इन क्षेत्रों तक पहुंच उन वर्गों के लिए पुनर्निर्देशित की जाती है जो संबंधित एमबीसी नियंत्रकों द्वारा कार्यान्वित किए जाते हैं, और उन्हें यह तय करने दें कि कहां, कैसे और क्या। आइए दो उदाहरण देखें - MBC 2 और MMM01। पहला एक उदाहरण है जो आपको बाकी को लागू करने की अनुमति देगा। MMM01 एक बल्कि अजीब MBC है।इस पर व्यावहारिक रूप से कोई दस्तावेज नहीं है, और इसका कार्यान्वयन अन्य एमबीसी से काफी अलग है। डीएमजी इम्यूलेशन में इस अंतर को भरने के लिए यह चोट नहीं करता है।

आरंभ करने के लिए, आइए आधार वर्ग MBC प्राप्त करें। यह इस तरह दिखेगा:

 const int ROMBankSize = 0x4000; const int RAMBankSize = 0x2000; class MBC { public: virtual void Write(WORD addr, BYTE value) = 0; virtual BYTE Read(WORD addr) = 0; virtual bool SaveRAM(const char *path, DWORD RAMSize); virtual bool LoadRAM(const char *path, DWORD RAMSize); protected: MBC(BYTE *ROM, DWORD ROMSize, BYTE *RAMBanks, DWORD RAMSize) : ROM(ROM), ROMSize(ROMSize), RAMBanks(RAMBanks), RAMSize(RAMSize) {} BYTE *ROM; BYTE *RAMBanks; DWORD ROMOffset; DWORD RAMOffset; DWORD ROMSize; DWORD RAMSize; };

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

रोम। यहां हमारे पास खेल की पूरी छवि है।
RAMBanks। यहां कारतूस की रैम है।
RAMOffset और ROMOffset। ये ऐसे ऑफ़सेट हैं जो वर्तमान मेमोरी बैंक को दर्शाते हैं।
ROMSize और RAMSize, मुझे लगता है, स्पष्टीकरण की आवश्यकता नहीं है। मान मेमोरी बैंकों में संग्रहीत होते हैं, बाइट्स में नहीं।

बेस क्लास खत्म हो गया है, अब चलिए उस क्लास को लागू करना शुरू करते हैं जो MBC2 का अनुकरण करता है। आइए कोड को तुरंत देखें, और फिर हम यह पता लगाएंगे कि यह नियंत्रक कैसे काम करता है:

 class MBC2 : public MBC { public: MBC2(BYTE *ROM, DWORD ROMSize, BYTE *RAMBanks, DWORD RAMSize) : MBC(ROM, ROMSize, RAMBanks, RAMSize) { ROMOffset = ROMBankSize; RAMOffset = 0; } virtual void Write(WORD addr, BYTE value) { switch (addr & 0xF000) { //ROM bank switching case 0x2000: case 0x3000: ROMOffset = value & 0xF; ROMOffset %= ROMSize; if (ROMOffset == 0) { ROMOffset = 1; } ROMOffset *= ROMBankSize; break; //RAM bank 0 case 0xA000: case 0xB000: RAMBanks[addr - 0xA000] = value & 0xF; break; } } virtual BYTE Read(WORD addr) { switch (addr & 0xF000) { //ROM bank 0 case 0x0000: case 0x1000: case 0x2000: case 0x3000: return ROM[addr]; //ROM bank 1 case 0x4000: case 0x5000: case 0x6000: case 0x7000: return ROM[ROMOffset + (addr - 0x4000)]; //RAM bank 0 case 0xA000: case 0xB000: return RAMBanks[addr - 0xA000] & 0xF; } return 0xFF; } };

पढ़ना आसान है। ROMOffset को वर्तमान ROM बैंक तक पहुँचने के लिए एक ऑफसेट के रूप में उपयोग किया जाता है। रैम के साथ एक विवरण है। MBC2 में 512 4-बिट रैम ब्लॉक हैं। बेशक, हम सभी 512 बाइट्स आवंटित करते हैं, बस संचालन लिखते हैं और मानों को कम से कम 4 महत्वपूर्ण बिट्स तक काटते हैं।

अब रिकॉर्डिंग समारोह। यह वह जगह है जहाँ MBC तर्क का अनुकरण किया जाता है। MBC2 केवल ROM बैंकों को बदलने का समर्थन करता है। वे पता क्षेत्र 0x2000-0x3FFF में 4 बिट्स की लंबाई के साथ एक बैंक नंबर लिखकर बदलते हैं। आप एक शून्य बैंक का चयन नहीं कर सकते, क्योंकि यह पहले से ही 0x0000-0x3FFF पर है। यह ROM की सीमाओं की जाँच करने के लायक भी है। अनिर्दिष्ट कारण के लिए कुछ गेम, एक ऐसे बैंक को चुनने की कोशिश करते हैं जो मौजूद नहीं है। यह स्वाभाविक रूप से एक त्रुटि की ओर जाता है। खेल सत्यापन के साथ काम करता है, जैसे कि कुछ भी नहीं हुआ था। ऐसा ही एक गेम है WordZap। शायद ये गलत एमुलेशन के परिणाम हैं (मैं स्वाभाविक रूप से सही डीएमजी एम्यूलेशन का नाटक नहीं करता हूं), लेकिन किसी भी मामले में, चेक को चोट नहीं पहुंचेगी।

हां, 0xFF गलती से नहीं लौटा है - DMG पर यह मान तब लौटाया जाता है जब सामग्री परिभाषित नहीं होती है।

अंत में, MMM01 पर विचार करें। मैं अपने कोड की शुद्धता के बारे में सुनिश्चित नहीं हूं, क्योंकि इस नियंत्रक का वर्णन मंच पर पाया गया था, और यह एक अज्ञात व्यक्ति द्वारा लिखा गया था। कोड:

 class MBC_MMM01 : public MBC { public: enum MMM01ModesEnum { MMM01MODE_ROMONLY = 0, MMM01MODE_BANKING = 1 }; MBC_MMM01(BYTE *ROM, DWORD ROMSize, BYTE *RAMBanks, DWORD RAMSize) : MBC(ROM, ROMSize, RAMBanks, RAMSize) { ROMOffset = ROMBankSize; RAMOffset = 0; RAMEnabled = false; Mode = MMM01MODE_ROMONLY; ROMBase = 0x0; } virtual void Write(WORD addr, BYTE value) { switch (addr & 0xF000) { //Modes switching case 0x0000: case 0x1000: if (Mode == MMM01MODE_ROMONLY) { Mode = MMM01MODE_BANKING; } else { RAMEnabled = (value & 0x0F) == 0x0A; } break; //ROM bank switching case 0x2000: case 0x3000: if (Mode == MMM01MODE_ROMONLY) { ROMBase = value & 0x3F; ROMBase %= ROMSize - 2; ROMBase *= ROMBankSize; } else { if (value + ROMBase / ROMBankSize > ROMSize - 3) { value = (ROMSize - 3 - ROMBase / ROMBankSize) & 0xFF; } ROMOffset = value * ROMBankSize; } break; //RAM bank switching in banking mode case 0x4000: case 0x5000: if (Mode == MMM01MODE_BANKING) { value %= RAMSize; RAMOffset = value * RAMBankSize; } break; //Switchable RAM bank case 0xA000: case 0xB000: if (RAMEnabled) { RAMBanks[RAMOffset + (addr - 0xA000)] = value; } break; } } virtual BYTE Read(WORD addr) { if (Mode == MMM01MODE_ROMONLY) { switch (addr & 0xF000) { //ROM bank 0 case 0x0000: case 0x1000: case 0x2000: case 0x3000: //ROM bank 1 case 0x4000: case 0x5000: case 0x6000: case 0x7000: return ROM[addr]; //Switchable RAM bank case 0xA000: case 0xB000: if (RAMEnabled) { return RAMBanks[RAMOffset + (addr - 0xA000)]; } } } else { switch (addr & 0xF000) { //ROM bank 0 case 0x0000: case 0x1000: case 0x2000: case 0x3000: return ROM[ROMBankSize * 2 + ROMBase + addr]; //ROM bank 1 case 0x4000: case 0x5000: case 0x6000: case 0x7000: return ROM[ROMBankSize * 2 + ROMBase + ROMOffset + (addr - 0x4000)]; //Switchable RAM bank case 0xA000: case 0xB000: if (RAMEnabled) { return RAMBanks[RAMOffset + (addr - 0xA000)]; } } } return 0xFF; } private: bool RAMEnabled; MMM01ModesEnum Mode; DWORD ROMBase; };

जैसा कि आप देख सकते हैं, बहुत सारे कोड हैं। मैं प्रत्येक पंक्ति की व्याख्या नहीं करूंगा - पिछले उदाहरण के बाद, मुझे आशा है कि आपके लिए यह समझना मुश्किल नहीं होगा कि क्या किया जा रहा है और क्यों। मैं केवल यह कह सकता हूं कि MMM01 का उपयोग केवल 2 गेम में किया जाना लगता है, इसलिए यह कोई संयोग नहीं है कि यह सभी एमुलेटर में नहीं है।

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

समय एक और महत्वपूर्ण विशेषता के लिए आ गया है - एक फ़ाइल से रॉम लोड करना। छवि को मेमोरी में लोड करने से पहले, यह उल्लेख करने का समय है कि जब आप डीएमजी चालू करते हैं तो क्या होता है।

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

एक रोचक तथ्य। बूटस्ट्रैप ROM को बहुत पहले नहीं प्राप्त किया गया था, और उन्होंने इसे प्रोसेसर चिप की एक तस्वीर के माध्यम से निकाला। लेखक ने प्रोसेसर के उस हिस्से की तस्वीर ली जिसमें यह ROM स्थित था, और आंख पर एक बिट ने सभी सामग्रियों को गिना।

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

निश्चित रूप से, मैं हर बार इस छवि को लॉन्च नहीं करना चाहूंगा। ऐसा करने के लिए, आप निम्न कार्य कर सकते हैं। पीसी रजिस्टर 0x100 होना चाहिए - यह वह पता है जहां खेल की छवियों में पहली टीम स्थित है। इसके अलावा, सभी प्रोसेसर रजिस्टर और I / O पोर्ट मेमोरी एरिया को उन मानों के साथ आरंभीकृत किया जाना चाहिए जो बूटस्ट्रैप रोम को पीछे छोड़ते हैं - ये मान CPU मैनुअल में पाए जा सकते हैं। सभी खेल अपने आप ही सभी आवश्यक मूल्यों को सेट करने के लिए अच्छी तरह से नहीं लिखे जाते हैं, कुछ बूटस्ट्रैप रोम चलाने के बाद निर्धारित मूल्यों पर भरोसा कर सकते हैं। ऐसा करने के लिए, सभी घटकों में EmulateBIOS फ़ंक्शन होता है, जिसके माध्यम से सभी आवश्यक मान सेट किए जाते हैं।

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

 BYTE Complement = 0; for (int i = 0x134; i <= 0x14C; i++) { Complement = Complement - ROM[i] - 1; } if (Complement != ROM[0x14D]) { //   }

यदि चेक पास हो गए हैं, तो हम कारतूस की रैम के लिए जगह आवंटित करते हैं और इसी एमबीसी चिप का एक ऑब्जेक्ट बनाते हैं।

कारतूस की रैम के बारे में, यह हमेशा अच्छा होता है कि हाथ में कम से कम एक मेमोरी बैंक हो, भले ही छवि "कहे" कि इसका उपयोग नहीं किया गया है। कुछ गेम एमबीसी के बिना कारतूस होने का दिखावा करते हैं, लेकिन, फिर भी, उनके पास केवल रैम के लिए एक साधारण चिप हो सकती है।

स्मृति के साथ सब कुछ खत्म हो गया है।

निष्कर्ष

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

गेमबॉय एमुलेटर लिखना, भाग 1