एक एमुलेटर आर्केड मशीन बनाना। भाग ४

पहले , दूसरे , तीसरे भाग ।

मशीन के बाकी

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

(आपको मशीन के सर्किट आरेख को देखने में रुचि हो सकती है।)

समय

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

बीच में आता है

इंटरप्ट को डिज़ाइन किया गया है ताकि प्रोसेसर सटीक निष्पादन समय के साथ कार्यों को संसाधित कर सके, जैसे कि I / O। प्रोसेसर प्रोग्राम को निष्पादित कर सकता है, और जब बाधित पिन चालू हो जाता है, तो यह वर्तमान प्रोग्राम को निष्पादित करना बंद कर देता है और कुछ और करता है।

हमें उस तरह से अनुकरण करने की आवश्यकता है जिस तरह से एक आर्केड मशीन व्यवधान उत्पन्न करती है।

ग्राफिक्स

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

बटन

गेम में भौतिक बटन हैं जो प्रोग्राम 8080 प्रोसेसर के IN कमांड का उपयोग करके पढ़ता है। हमारे एमुलेटर को इन IN कमांड पर कीबोर्ड इनपुट को बांधने की आवश्यकता होगी।

ROM और RAM

मुझे स्वीकार करना चाहिए: हमने 16-किलोबाइट मेमोरी बफर बनाकर "कोने को काट दिया", जिसमें प्रोसेसर मेमोरी आवंटन के निचले 16 केबी शामिल हैं। वास्तव में, मेमोरी आवंटन का पहला 2 KB एक वास्तविक रीड-ओनली मेमोरी (ROM) है। हमें एक फ़ंक्शन में मेमोरी में लिखने के संचालन की आवश्यकता होगी ताकि रॉम को लिखना संभव न हो।

ध्वनि

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

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

प्रदर्शित करता है और अद्यतन करता है

मूल बातें

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

स्मृति आवंटन और कोड कार्यक्षमता के उद्देश्य का विश्लेषण करने के लिए सिस्टम की गहरी समझ हमारी मदद करेगी।

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

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

अंतराल से बचने के लिए, स्क्रीन अपडेट के स्थान को स्थानांतरित करने से बचने के लिए सॉफ़्टवेयर को कुछ करना चाहिए। और ऐसा करने का केवल एक ही तरीका है।

वीबीएल अंतिम पंक्ति के अंत के बाद उत्पन्न होता है, और आमतौर पर पहली पंक्ति को फिर से ड्राइंग करने से पहले एक निश्चित समय होता है। (यह वर्टिकल ब्लैंक समय है, और यह लगभग 1 मिली सेकेंड हो सकता है।)

जब वीबीएल प्राप्त होता है, तो प्रोग्राम ऊपर से स्क्रीन को प्रस्तुत करना शुरू कर देता है।

फ़्रेम स्कैन रिवर्स प्रक्रिया से पहले प्रत्येक रेखा खींची जाती है।

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

अंतरिक्ष आक्रमणकारियों वीडियो प्रणाली

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

हमें ऐसे अवरोध उत्पन्न करने के लिए अपनी मशीन के अनुकरण को बाध्य करना चाहिए। यदि हम उन्हें 60 हर्ट्ज की आवृत्ति के साथ-साथ अंतरिक्ष आक्रमणकारियों की मशीन के साथ उत्पन्न करेंगे, तो खेल सही आवृत्ति के साथ तैयार किया जाएगा।

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

बटन और बंदरगाहों

IN और OUT निर्देशों का उपयोग करके 8080 मैं / O लागू करता है। इसमें 8 अलग-अलग IN और OUT पोर्ट हैं - पोर्ट कमांड के डेटा बाइट द्वारा निर्धारित किया जाता है। उदाहरण के लिए, IN 3 रजिस्टर A में पोर्ट 3 का मान रखेगा, और OUT 2 पोर्ट 2 पर A भेजेगा।

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

:
1
0 (0, )
1 Start
2 Start
3 ?
4
5
6
7 ?

2
0,1 DIP- (0:3,1:4,2:5,3:6)
2 ""
3 DIP- , 1:1000,0:1500
4
5
6
7 DIP-, 1:,0:

3

2 ( 0,1,2)
3
4
5
6 "" ? , ,
(0=a,1=b,2=c ..)

( 3,5,6 1=$01 2=$00
, (attract mode))

हमारे सॉफ्टवेयर स्टैक में I / O को लागू करने के तीन तरीके हैं (जिसमें 8080 एमुलेटर, मशीन कोड और प्लेटफ़ॉर्म कोड शामिल हैं)।

1. हमारे 8080 एमुलेटर में मशीन ज्ञान एम्बेड करें
2. मशीन कोड में 8080 एमुलेटर ज्ञान एम्बेड करें
3. एपीआई के माध्यम से सूचना के आदान-प्रदान को सक्षम करने के लिए कोड के तीन भागों के बीच एक औपचारिक इंटरफ़ेस का आविष्कार करें

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

मैंने विकल्प 2 चुना। मुझे पहले कोड दिखाने दें:

  while (!done) { uint8_t opcode = state->memory[state->pc]; if (*opcode == 0xdb) //machine specific handling for IN { uint8_t port = opcode[1]; state->a = MachineIN(state, port); state->pc++; } else if (*opcode == 0xd3) //OUT { uint8_t port = opcode[1]; MachineOUT(state, port); state->pc++; } else Emulate8080Op(state); } 

यह कोड IN और OUT के लिए एक ही परत में opcodes के प्रसंस्करण को फिर से लागू करता है, जो बाकी कमांड के लिए एमुलेटर को कॉल करता है। मेरी राय में, यह कोड को क्लीनर बनाता है। यह दो आदेशों के लिए एक ओवरराइड या उपवर्ग के समान है, जो एक ऑटोमेटन परत को संदर्भित करता है।

नुकसान यह है कि हम दो स्थानों पर opcodes के उत्सर्जन को स्थानांतरित करते हैं। तीसरा विकल्प चुनने के लिए मैं आपको दोषी नहीं ठहराऊंगा। दूसरे विकल्प में, कम कोड की आवश्यकता होती है, लेकिन विकल्प 3 अधिक "स्वच्छ" है, लेकिन कीमत जटिलता में वृद्धि है। यह स्टाइल की पसंद का मामला है।

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

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

मुझे नहीं लगता कि मैं इसे कंप्यूटर पुरातत्व के उत्कृष्ट विश्लेषण से बेहतर समझा सकता हूं:

; 16- :
; f 0
; xxxxxxxxyyyyyyyy
;
; 4 x y, x, :
; $0000,
; write $aa -> $aa00,
; write $ff -> $ffaa,
; write $12 -> $12ff, ..
;
; 2 ( 0,1,2) 8- , :
; offset 0:
; rrrrrrrr result=xxxxxxxx
; xxxxxxxxyyyyyyyy
;
; offset 2:
; rrrrrrrr result=xxxxxxyy
; xxxxxxxxyyyyyyyy
;
; offset 7:
; rrrrrrrr result=xyyyyyyy
; xxxxxxxxyyyyyyyy
;
; 3 .

OUT कमांड के लिए, पोर्ट 2 में लिखना शिफ्ट की मात्रा सेट करता है, और पोर्ट 4 में लिखने से शिफ्ट रजिस्टर में डेटा सेट होता है। शिफ्ट की राशि से स्थानांतरित 3 रिटर्न डेटा के साथ पढ़ना। मेरी मशीन में, इसे इस तरह लागू किया जाता है:

  -(uint8_t) MachineIN(uint8_t port) { uint8_t a; switch(port) { case 3: { uint16_t v = (shift1<<8) | shift0; a = ((v >> (8-shift_offset)) & 0xff); } break; } return a; } -(void) MachineOUT(uint8_t port, uint8_t value) { switch(port) { case 2: shift_offset = value & 0x7; break; case 4: shift0 = shift1; shift1 = value; break; } } 

कीबोर्ड

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

  if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { if (msg.message==WM_KEYDOWN ) { if ( msg.wParam == VK_LEFT ) MachineKeyDown(LEFT); } else if (msg.message==WM_KEYUP ) { if ( msg.wParam == VK_LEFT ) MachineKeyUp(LEFT); } } 

एमुलेटर कोड के लिए प्लेटफ़ॉर्म कोड को चिपके हुए मशीन कोड कुछ इस तरह दिखाई देगा:

  MachineKeyDown(char key) { switch(key) { case LEFT: port[1] |= 0x20; //Set bit 5 of port 1 break; case RIGHT: port[1] |= 0x40; //Set bit 6 of port 1 break; /*....*/ } } PlatformKeyUp(char key) { switch(key) { case LEFT: port[1] &= 0xDF //Clear bit 5 of port 1 break; case RIGHT: port[1] &= 0xBF //Clear bit 6 of port 1 break; /*....*/ } } 

यदि आप चाहें, तो आप मशीन के कोड और प्लेटफ़ॉर्म को अपनी इच्छानुसार जोड़ सकते हैं - यह कार्यान्वयन का विकल्प है। मैं ऐसा नहीं करूंगा क्योंकि मैं मशीन को कई अलग-अलग प्लेटफार्मों पर पोर्ट करने जा रहा हूं।

बीच में आता है

मैनुअल का अध्ययन करने के बाद, मैंने महसूस किया कि 8080 हैंडल इस प्रकार हैं:

1. इंटरप्ट सोर्स (CPU में बाहरी) CPU इंटरप्ट पिन को सेट करता है।
2. जब CPU पुष्टि करता है कि इंटरप्ट प्राप्त हो गया है, तो इंटरप्ट का स्रोत किसी भी ओपोड को बस में भेज सकता है और CPU उसे देखता है। (ज्यादातर वे आरएसटी कमांड का उपयोग करते हैं।)
3. CPU इस कमांड को निष्पादित करता है। यदि यह आरएसटी है, तो यह मेमोरी के निचले भाग में एक निश्चित पते के लिए कॉल कमांड का एक एनालॉग है। यह स्टैक पर वर्तमान पीसी को धक्का देता है।
4. निचले मेमोरी एड्रेस कोड में कोड प्रोग्राम को बताने के लिए क्या प्रक्रिया चाहता है। प्रसंस्करण पूरा होने के बाद, RST, RET पर कॉल के साथ समाप्त होता है।

खेल के वीडियो उपकरण दो व्यवधान उत्पन्न करते हैं जिन्हें हमें प्रोग्रामेटिक रूप से अनुकरण करना चाहिए: फ्रेम का अंत और फ्रेम के बीच का। दोनों 60 हर्ट्ज (प्रति सेकंड 60 बार) पर किए जाते हैं। एक सेकंड का 1/60 16.6667 मिलीसेकंड है।

इंटरप्ट के साथ काम करना आसान करने के लिए, मैं 8080 एमुलेटर पर एक फ़ंक्शन जोड़ूंगा:

  void GenerateInterrupt(State8080* state, int interrupt_num) { //perform "PUSH PC" Push(state, (state->pc & 0xFF00) >> 8, (state->pc & 0xff)); //Set the PC to the low memory vector. //This is identical to an "RST interrupt_num" instruction. state->pc = 8 * interrupt_num; } 

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

  while (!done) { Emulate8080Op(state); if ( time() - lastInterrupt > 1.0/60.0) //1/60 second has elapsed { //only do an interrupt if they are enabled if (state->int_enable) { GenerateInterrupt(state, 2); //interrupt 2 //Save the time we did this lastInterrupt = time(); } } } 

कुछ विवरण हैं कि 8080 वास्तव में कैसे बाधित होता है, जिसका हम अनुकरण नहीं करेंगे। मेरा मानना ​​है कि इस तरह के प्रसंस्करण हमारे उद्देश्यों के लिए पर्याप्त होंगे।