💯 👨🏻‍✈️ ❇️ Arduino का संघ और क्लासिक प्रोसेसर 🍋 📭 🤞🏿

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

लेकिन प्रोसेसर को काम करने के लिए इतनी आवश्यकता है! फिर से, दुविधा: उसी वर्ष के वास्तविक चिप्स लें, या एफपीजीए में सब कुछ डाल दें, प्रोसेसर को बाहर छोड़ दें? हालांकि, FPGA क्यों आवश्यक है? अरुडिनो और क्लासिक प्रोसेसर के लंबे समय तक रहना!

अपने Arduino को "दूसरा मस्तिष्क" दें और इसे और अधिक स्मार्ट बनाएं।

एक सच्चा आठ-बिट माइक्रोप्रोसेसर प्रोग्राम चलाता है, जबकि एक Arduino ROM, RAM और सरल बाह्य उपकरणों का अनुकरण करता है।

Arduino IDE में वर्चुअल बाह्य उपकरणों को डिज़ाइन करें, और माइक्रोप्रोसेसर पर कोडांतरक कोड चलाएं। जटिल सर्किट और फ्लैश समानांतर रोम को इकट्ठा करने की आवश्यकता नहीं है।

समर्थित माइक्रोप्रोसेसरों: 6502, 6809 और Z80 (18581), अन्य रास्ते में हैं।

माइक्रोप्रोसेसर के साथ एक ढाल अन्य ढालों को जोड़ने में हस्तक्षेप नहीं करता है: एलसीडी, मेमोरी कार्ड, आदि के साथ।

स्व-असेंबली भाषा के अलावा, आप माइक्रोप्रोसेसर पर कुछ क्लासिक कोड चलाने की कोशिश कर सकते हैं।

सच है, माइक्रोप्रोसेसर बहुत कम आवृत्ति पर काम करेगा - लगभग 95 kHz, इसका सटीक मूल्य परिधीय अनुकरण कोड के अनुकूलन पर निर्भर करता है।

पता स्थान का वितरण एक स्केच में प्रोग्रामेटिक रूप से सेट किया गया है। माइक्रोप्रोसेसर को Arduino Mega पर उपलब्ध 4 kB 8 kB RAM से आवंटित किया जा सकता है। ROM उपलब्ध 256 के 200 kB से अधिक का आवंटन कर सकता है।

Arduino मेगा सीरियल पोर्ट UART का अनुकरण कर सकता है।

सर्किट, बोर्ड चित्र, Gerber फाइलें CC-BY-SA 4.0 के तहत यहां उपलब्ध हैं । उसी समय, README.md फ़ाइल संलग्न करने की आवश्यकता है, क्योंकि इसमें निम्नलिखित चेतावनी शामिल है:

परिधीय अनुकरण स्केच अपलोड होने तक ढाल को कनेक्ट न करें! अन्यथा, माइक्रोप्रोसेसर के आउटपुट लाइनों को छोटा करना संभव है।

हां, और स्केच में ही, किसी चीज को उसी कारण से सावधानीपूर्वक फिर से बनाने की आवश्यकता है।

6502 पर डिवाइस की योजना:

6809 पर डिवाइस की योजना:

Z80 पर डिवाइस की योजना:

आप पहले से ही चला सकते हैं:

6502 के साथ एक डिवाइस पर - ऐप्पल I, वॉज़ मॉनिटर + रोम विथ बेसिक

6809 के साथ एक उपकरण पर - एक ही डेवलपर के घर-निर्मित कंप्यूटर सिमोन 6809 का एक एनालॉग, कोडांतरक और डिस्सेम्बलर के साथ एक प्रशिक्षण मॉनिटर।

Z80 के साथ एक डिवाइस पर - अब तक केवल सीरियल पोर्ट की एक इको टेस्ट , आपको वर्चुअल 8251 (KR580VV51A) के प्रदर्शन की जांच करने की अनुमति देता है।

बाह्य उपकरणों के अनुकरण के लिए फर्मवेयर - एमआईटी लाइसेंस के तहत।

कार्रवाई के सिद्धांत का संक्षिप्त विवरण:

6502 डिवाइस को

6809 पर डिवाइस करने के लिए

Z80 पर डिवाइस के लिए - तैयारी में।

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

यह RCA1802, 68008, 8085 (182185), 8088 (181088) पर समान बोर्ड विकसित करने की योजना है। K1801BM1 के बारे में नहीं कहा गया है, लेकिन आप लेखक को इस तरह के विचार को फेंक सकते हैं।

फाइलें:

6502 पर डिवाइस के लिए: विधानसभा निर्देश , सिल्क स्क्रीन प्रिंटिंग , आरेख

6809 पर डिवाइस के लिए: विधानसभा निर्देश , सिल्क स्क्रीन प्रिंटिंग , आरेख

Z80 पर डिवाइस के लिए: विधानसभा निर्देश , सिल्क स्क्रीन प्रिंटिंग , आरेख

एक Arduino और एक 6502 डिवाइस की बातचीत पर विचार करें। Arduino समय-समय पर एक माइक्रोप्रोसेसर के इनपुट में स्तर को बदलता है जिसे घड़ी की दालों को शून्य से एक और इसके विपरीत आपूर्ति करने के लिए डिज़ाइन किया गया है। प्रत्येक चक्र पर, यह जांचता है कि नियंत्रण रेखा और पता बस पर क्या हो रहा है, और स्थिति के आधार पर, डेटा बस से जानकारी पढ़ता है या वहां भेजता है। Arduino IRQ और NMI लाइनों को भी नियंत्रित कर सकता है, जिससे रुकावटें पैदा हो सकती हैं। आंकड़ा डेटा के प्रकार और उनके संचरण की दिशाओं को दर्शाता है:

Arduino पोर्ट्स और माइक्रोप्रोसेसर आउटपुट के पत्राचार को स्केच में कॉन्फ़िगर किया गया है:

/* Digital Pin Assignments */ #define DATA_OUT PORTL #define DATA_IN PINL #define ADDR_H PINC #define ADDR_L PINA #define ADDR ((unsigned int) (ADDR_H << 8 | ADDR_L)) #define uP_RESET_N 38 #define uP_RW_N 40 #define uP_RDY 39 #define uP_SO_N 41 #define uP_IRQ_N 50 #define uP_NMI_N 51 #define uP_E 52 #define uP_GPIO 53

हम प्रत्येक उपाय को निम्नलिखित घटनाओं में विभाजित करेंगे:

CLK राज्य को एक से शून्य में बदलता है (गिरावट)
सीएलके शून्य की स्थिति में है
CLK राज्य को एक से शून्य में बदल देता है (उदय)
सीएलके इकाई अवस्था में है
CLK फिर से राज्य को एक से शून्य में बदलता है ...

राज्य परिवर्तन के क्षणों के दौरान क्या होता है?

6502 इनपुट CLK0 पर घड़ी की दाल प्राप्त करता है, उन्हें बफ़र करता है और उन्हें दो आउटपुट पर भेजता है: CLK1 और CLK2। यद्यपि माइक्रोप्रोसेसर में सभी घटनाएँ CLK1 से जुड़ी होती हैं, हम मानते हैं कि विलंब छोटा है, और वे CLK0 से बंधे हैं - वह रेखा जिसके साथ माइक्रोप्रोसेसर को Arduino से घड़ी की दालें मिलती हैं। और सिग्नल को सिर्फ CLK कहें।

1. सीएलके राज्य को एक से शून्य में बदलता है।

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

3. सीएलके इकाई अवस्था में जाता है, और इसका अर्थ है कि डेटा का आदान-प्रदान शुरू हो गया है। यदि यह एक रीड ऑपरेशन है, तो माइक्रोप्रोसेसर डेटा बस आउटपुट को इनपुट स्थिति में स्थानांतरित करता है और डेटा प्राप्त करता है, और यदि राइट ऑपरेशन होता है, तो यह उन्हें आउटपुट स्थिति में स्थानांतरित करता है और डेटा भेजता है। और R / W सिग्नल बाहरी डिवाइस को लिखने या पढ़ने के मोड में स्विच करता है, जो माइक्रोप्रोसेसर की संबंधित स्थिति के विपरीत है।

4. सीएलके शून्य पर जाता है। अब न तो माइक्रोप्रोसेसर और न ही इनपुट-आउटपुट डिवाइस डेटा बस में कुछ भी आउटपुट करते हैं। माइक्रोप्रोसेसर डेटा बस लाइन और R / W पिन को नए राज्य में सेट कर सकता है।

एक सरल व्याख्या, बच्चे के लिए समझने योग्य। जो कभी भी इन "पर्दे के पीछे की साज़िशों" के बारे में नहीं सोचता, अगर वह केवल माइक्रोकंट्रोलर को प्रोग्राम करेगा। असेंबलर में भी।

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

इसलिए, हमें Arduino को घड़ी की दालों को उत्पन्न करने के लिए "सिखाने" की आवश्यकता है, लगातार यह पता लगाना कि एड्रेस बस और R / W लाइन पर क्या होता है, और तदनुसार डेटा बस के साथ बातचीत करना। ऐसा करने के लिए, स्केच में टाइमर 1 टाइमर इंटरप्ट का उपयोग किया जाता है, जो 95 kHz की आवृत्ति के साथ दालों को उत्पन्न करता है। Arduino माइक्रोप्रोसेसर की तुलना में बहुत तेज़ी से काम करता है, और इसलिए, इसकी घड़ियों के बीच, यह सब कुछ पढ़ने और तैयार करने का प्रबंधन करता है। यह सुनिश्चित करना महत्वपूर्ण है कि स्केच को संशोधित करने के बाद इस स्थिति को पूरा करना जारी है।

यहाँ स्केच से एक अंश है, जो दिखाता है कि सीएलके शून्य से एक तक कैसे जाता है, और आगे क्या होता है:

 //////////////////////////////////////////////////////////////////// // Processor Control Loop //////////////////////////////////////////////////////////////////// // This is where the action is. // it reads processor control signals and acts accordingly. // ISR(TIMER1_COMPA_vect) { // Drive CLK high CLK_E_HIGH; // Let's capture the ADDR bus uP_ADDR = ADDR; if (STATE_RW_N) ////////////////////////////////////////////////////////////////// // HIGH = READ transaction { // uP wants to read so Arduino to drive databus to uP: DATA_DIR = DIR_OUT; // Check what device uP_ADDR corresponds to: // ROM? if ( (ROM_START <= uP_ADDR) && (uP_ADDR <= ROM_END) ) DATA_OUT = pgm_read_byte_near(rom_bin + (uP_ADDR - ROM_START)); else if ( (BASIC_START <= uP_ADDR) && (uP_ADDR <= BASIC_END) ) DATA_OUT = pgm_read_byte_near(basic_bin + (uP_ADDR - BASIC_START)); else // RAM? if ( (uP_ADDR <= RAM_END) && (RAM_START <= uP_ADDR) ) DATA_OUT = RAM[uP_ADDR - RAM_START]; else // 6821? if ( KBD <=uP_ADDR && uP_ADDR <= DSPCR ) { // KBD? if (uP_ADDR == KBD) { ... // handle KBD register } else // KBDCR? if (uP_ADDR == KBDCR) { ... // handle KBDCR register } else // DSP? if (uP_ADDR == DSP) { ... // handle DSP register } else // DSPCR? if (uP_ADDR == DSPCR) { ... // handle DSPCR register } } } else ////////////////////////////////////////////////////////////////// // R/W = LOW = WRITE { // RAM? if ( (uP_ADDR <= RAM_END) && (RAM_START <= uP_ADDR) ) RAM[uP_ADDR - RAM_START] = DATA_IN; else // 6821? if ( KBD <=uP_ADDR && uP_ADDR <= DSPCR ) { // KBD? if (uP_ADDR == KBD) { ... // handle KBD register } else // KBDCR? if (uP_ADDR == KBDCR) { ... // handle KBDCR register } else // DSP? if (uP_ADDR == DSP) { ... // handle DSP register } else // DSPCR? if (uP_ADDR == DSPCR) { ... // handle DSPCR register } } } //////////////////////////////////////////////////////////////// // We are done with this cycle. // one full cycle complete clock_cycle_count ++; // start next cycle CLK_E_LOW; // If Arduino was driving the bus, no need anymore. // natural delay for DATA Hold time after CLK goes low (t_HR) DATA_DIR = DIR_IN; }

एड्रेस स्पेस का आवंटन किसी भी तरह से किया जा सकता है, एक अनमॉडिफाइड स्केच में यह Apple 1 के समान है, जिसमें 256 बाइट्स ROM के साथ, BASIC के लिए 8 किलोबाइट रोम, 4 किलोबाइट रैम और 6821 इनपुट-आउटपुट डिवाइस है।

 // MEMORY LAYOUT // 4K MEMORY #define RAM_START 0x0000 #define RAM_END 0x0FFF byte RAM[RAM_END-RAM_START+1]; // ROMs (Monitor + Basic) #define ROM_START 0xFF00 #define ROM_END 0xFFFF #define BASIC_START 0xE000 #define BASIC_END 0xEFFF //////////////////////////////////////////////////////////////////// // Woz Monitor Code //////////////////////////////////////////////////////////////////// // PROGMEM const unsigned char rom_bin[] = { 0xd8, 0x58, 0xa0, 0x7f, 0x8c, 0x12, 0xd0, 0xa9, 0xa7, 0x8d, 0x11, 0xd0, ... 0x00, 0xff, 0x00, 0x00 }; // BASIC ROM starts at E000 PROGMEM const unsigned char basic_bin[] = { 0x4C, 0xB0, 0xE2, 0xAD, 0x11, 0xD0, 0x10, 0xFB, ... 0xE0, 0x80, 0xD0, 0x01, 0x88, 0x4C, 0x0C, 0xE0 };

RAM को बाइट RAM सरणी [RAM_END-RAM_START + 1] द्वारा अनुकरण किया जाता है। दो PROGMEM कीवर्ड की जरूरत है ताकि उत्सर्जित रोम की सामग्री को माइक्रोकंट्रोलर की फ्लैश मेमोरी में संग्रहीत किया जाए।

6821 पर्याप्त रूप से अनुकरणीय है कि वर्चुअल कीबोर्ड और डिस्प्ले "टर्मिनल" के माध्यम से काम करते हैं। Woz Monitor और BASIC काम करते हैं, जो कि लेखक ने मांगे हैं।

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

I / O डिवाइस माइक्रोप्रोसेसर के एड्रेस स्पेस में स्थित हैं; वे मेमोरी सेल्स की तरह ही एक्सेस होते हैं। "लोहा" बाह्य उपकरणों, जैसे कि एलसीडी डिस्प्ले, एक मेमोरी कार्ड, साउंड आउटपुट का उपयोग करने के लिए, आपको पता स्थान में एक जगह आवंटित करने की आवश्यकता है।

संदर्भ:

www.6502.org
www.callapple.org/soft/ap1/emul.html
skilldrick.imtqy.com/easy6502
searle.hostei.com/grant/6502/Simple6502.html
wilsonminesco.com/6502primer
एसबी-असेंबलर: www.sbprojects.net/sbasm

6809 पर जाएं, इसमें शामिल हैं:

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

माइक्रोप्रोसेसर 6809E (बाहरी) को एक बाहरी घड़ी की आवश्यकता होती है, जबकि 6809 में एक आंतरिक होता है। हिताची में, उन्हें क्रमशः 6309 ई और 6309 कहा जाता है, वे सामान्य लोगों से भिन्न होते हैं कि वे ऑपरेशन के अंदर 32-बिट फॉर्म में काम करते हैं, लेकिन क्लासिक संस्करण के साथ संगतता मोड में स्विच करना संभव है।

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

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

Arduino 6502 की तरह 6809 के साथ इंटरैक्ट करता है, लेकिन इसमें दो क्लॉक इनपुट हैं: E और Q, और तीन इंटरप्ट इनपुट: IRQ, FIRQ और NMI।

इस बार, Arduino बंदरगाहों और माइक्रोप्रोसेसर पिन के बीच पत्राचार निम्नानुसार कॉन्फ़िगर किया गया है:

 /* Digital Pin Assignments */ #define DATA_OUT PORTL #define DATA_IN PINL #define ADDR_H PINC #define ADDR_L PINA #define ADDR ((unsigned int) (ADDR_H << 8 | ADDR_L)) #define uP_RESET_N 38 #define uP_E 52 #define uP_Q 53 #define uP_RW_N 40 #define uP_FIRQ_N 41 #define uP_IRQ_N 50 #define uP_NMI_N 51 #define uP_GPIO 39

जैसा कि रेखांकन से देखा जा सकता है, संकेत क्यू अवधि के एक चौथाई से ई के सापेक्ष स्थानांतरित कर दिया गया है:

हम शायद ही क्यू पर ध्यान दें, क्योंकि सभी ईवेंट्स ई से बंधे हैं और सब कुछ इस तरह होता है:

ई शून्य पर स्विच करता है। प्रोसेसर पता बस पर एक नया पता सेट करता है और आर / डब्ल्यू लाइन की स्थिति को बदलता है।
ई एक पर स्विच करता है, प्रोसेसर डेटा एक्सचेंज के लिए तैयार हो जाता है।
इससे कोई फर्क नहीं पड़ता कि जब तक E एक है डेटा बस का क्या होता है, मुख्य बात यह है कि E के शून्य पर वापस जाने पर आवश्यक डेटा होता है।
डेटा पढ़ते समय, I / O डिवाइस को आवश्यक डेटा को बस E से एक से शून्य से पहले लाइन (सर्कल में संख्या 17 द्वारा न्यूनतम विलंब दिखाया गया है) तक पहुंचाना चाहिए।
रिकॉर्डिंग करते समय, I / O डिवाइस को कुछ रजिस्टर में उस रूप में डेटा को ठीक करना होगा जिसमें वह उस समय था जब E एक से शून्य हो गया था। प्रोसेसर इस डेटा को बस पर पहले भी प्रदान करेगा - क्यू के एक (सर्कल में संख्या 20) के संक्रमण के क्षण में।
ई के शून्य के संक्रमण के बाद, सब कुछ दोहराता है।

सब कुछ 6502 के बारे में ऊपर कहा गया है कि परिधीय डिवाइस (एक आभासी सहित) की आवश्यकता के बारे में सभी संकेतों को विकसित करने के लिए समय-समय पर 6809।

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

अनमोडिफ़ाइड स्केच में पता स्थान उसी तरह वितरित किया जाता है जैसे घर में बना साइमन 6809 कंप्यूटर:

 // MEMORY #define RAM_START 0x0000 #define RAM_END 0x0FFF #define ROM_START 0xE000 #define ROM_END 0xFFFF byte RAM[RAM_END-RAM_START+1]; //////////////////////////////////////////////////////////////////// // Monitor Code //////////////////////////////////////////////////////////////////// // static const unsigned char PROGMEM const unsigned char simon09_bin[] = { 0x1a, 0xff, 0x4f, 0x1f, 0x8b, 0x0f, 0x36, 0x7f, 0x01, 0xa5, 0x10, 0xce, ... 0x00, 0x09, 0x00, 0x0c, 0x00, 0x0f, 0xe0, 0x00 };

रैम और रोम को सरणियों में उसी तरह से संग्रहीत किया जाता है जैसे कि 6502 संस्करण में, एकमात्र अंतर यह है कि ROM डेटा के साथ केवल एक सरणी है।

I / O उपकरणों को भी पता स्थान के कुछ भाग आवंटित किए जाते हैं, और वे आभासी या वास्तविक हो सकते हैं। चूँकि सिमोन 6809 एक पुरानी मौलिक आधार पर आधारित एक आधुनिक मशीन है, यह पीसी से एफटीडीआई के माध्यम से डेटा का आदान-प्रदान करता है, जिस पर "टर्मिनल" चल रहा है। यहाँ इसका अनुकरण किया जाता है।

संदर्भ:

आर्टो पेज पर 6809 पर बहुत कुछ जानकारी
6809 को विकिपीडिया लेख
SWTPc 6809 सिस्टम
फ्लेक्स ऑपरेटिंग सिस्टम पर विकिपीडिया लेख

Arduino का संघ और क्लासिक प्रोसेसर

More articles: