🈶 👩🏽‍🤝‍👨🏿 🤺 माई लिटिल रिले: ट्रिपल ब्रेनफक, या व्हाट इज़ पागलपन ✳️ 👩🏾‍💼 👨🏼‍🚒

चित्र 1: BrainfuckPC अपने लेखक की पृष्ठभूमि में रिले कंप्यूटर

अपने craziest कंप्यूटर प्रोजेक्ट्स की वार्षिक डाइजेस्ट की गौरवशाली परंपरा को जारी रखते हुए, मैं आपके साथ BrainfuckPC रिले कंप्यूटर प्रोजेक्ट पर तीसरा और अंतिम लेख प्रस्तुत करता हूं।

पिछली श्रृंखला में:

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

कटर के तहत रिले ब्लॉक बज रहे हैं, दुनिया के सबसे तेज रिले गणना, रैप-अप, वैक्यूम संकेतक, और बहुत कुछ।

दिमाग की प्रोग्रामिंग भाषा

दिमाग की प्रोग्रामिंग भाषा शायद दुनिया की सबसे लोकप्रिय गूढ़ प्रोग्रामिंग भाषा है। और एक ही समय में असली ट्यूरिंग एक पूर्ण दलदल है । केवल 8 निर्देश जिस पर आप कुछ भी लिख सकते हैं, लेकिन बहुत लंबे समय के लिए।
उदाहरण के लिए, 355/113 डिवीजन प्रोग्राम को लिखने और डिबग करने में मुझे तीन दिन लगे, जो टर्मिनल में 6 दशमलव स्थानों को प्रिंट करता है।

चित्र 2: ब्रेनफॉक भाषा निर्देश

भाषा का पूरा सिंटैक्स 30 बिट मेमोरी सेल के लिए 8 बिट्स की क्षमता के साथ रैम के आसपास बनाया गया है।

दो + और - निर्देशों के साथ , हम वर्तमान डेटा सेल में मूल्य को एक या उससे ऊपर बदल देते हैं।
दो निर्देशों के साथ < और > हम सूचक को वर्तमान डेटा सेल में एक-एक करके बदलते हैं, जिससे मेमोरी के माध्यम से बाएं या दाएं बढ़ते हैं।
दो और निर्देश [ और ] - हमें लूप व्यवस्थित करने की अनुमति देते हैं। ब्रैकेट के अंदर सब कुछ लूप का शरीर है। नेस्टेड छोरों की अनुमति दी। निर्देश का तर्क सरल है - यदि वर्तमान डेटा सेल का मान शून्य के बराबर नहीं है - हम लूप के एक पुनरावृत्ति का प्रदर्शन करेंगे, यदि यह बराबर है, तो हम लूप से बाहर निकलते हैं।
आखिरी दो निर्देश । और , - आपको कंसोल में वर्तमान सेल के मूल्य को प्रदर्शित करने, या इसकी रैम दर्ज करने की अनुमति देता है। जिससे अन्तरक्रियाशीलता प्राप्त होती है।

हां, यह किसी भी कार्यक्रम को लिखने के लिए पर्याप्त से अधिक है। ब्रेनफॉक में सी कंपाइलरों का अस्तित्व इस ओर संकेत करता है। लेकिन कोड का घनत्व कोई नहीं है। सरल ऑपरेशन करने के लिए, जैसे दो मेमोरी कोशिकाओं के मूल्यों को जोड़ना, आपको सैकड़ों ब्रेनफक निर्देशों को निष्पादित करने की आवश्यकता है।

ब्रेनफॉक ++

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

चित्र 3: brainfuck ++ भाषा निर्देश

सिद्धांत से अभ्यास तक

जैसा कि आप समझते हैं, कोई भी दिमाग की भाषा में ऑपरेशन Rb = Ra + Rb नहीं लिख सकता है, जहाँ Ra और Rb मेमोरी सेल हैं। हम केवल एक सेल की सामग्री को एक स्थिरांक में बदल सकते हैं और जाँच सकते हैं कि क्या यह शून्य है। नतीजतन, दो नंबरों को जोड़ने के लिए, हमारे लिए जो सब रहता है वह है आरबी सेल के लिए +1 और आरए सेल के लिए -1, जब तक कि आरए सेल की सामग्री शून्य न हो जाए। हम इसे C में एक कोड के रूप में लिखते हैं:

/*(mem+RbPos) += *mem */ void addMov(Memory &mem, uint16_t RbPos) { while (*mem) { mem += RbPos; (*mem)++; mem -= RbPos; (*mem)--; } }

नतीजतन, पुराने मूल्य RbPos सेल में दिखाई देगा और साथ ही यह स्रोत के पते पर क्या था। कक्षा मेमोरी - 65k पूर्णांक कोशिकाओं के साथ एक कंटेनर। इसकी मुख्य संपत्ति यह है कि पॉइंटर के मूल्य को ओवरफ्लो करने से यह सरणी की शुरुआत में वापस आ जाएगा। जैसे मेरे असली हार्डवेयर में।

वर्णित फ़ंक्शन का नुकसान मूल मूल्य का नुकसान है - इसे शून्य पर रीसेट किया जाएगा। इसे बचाने के लिए एक और Rc वैरिएबल जोड़ें:

 /* *(mem+RcPos) = *mem *(mem+RbPos) += *mem */ void addCpy(Memory &mem, uint16_t RbPos, uint16_t RcPos) { while (*mem) { mem += RbPos; (*mem)++; mem -= RbPos; (*mem)--; mem += RcPos; (*mem)++; mem -= RcPos; } }

नतीजतन, कॉपी किया गया शब्द RcPos सेल में निहित होगा। खैर, इस घटना में कि शून्य हुआ करता था।

इस संकेतन के बाद से मैंने ब्रेनफॉक ++ से बहुत मिलता जुलता प्रयोग किया, हम बस bfpp वर्णों में अपने कार्य को फिर से लिखते हैं, उदाहरण के लिए 5 के लिए RbPos और 5 के लिए RcPos ले रहे हैं:

[
>>>>
+
<<<<
-
>>>>>
+
<<<<<
]

सभी प्राथमिकताओं का वर्णन करने के बाद, आप उन्हें और अधिक जटिल संरचनाओं में संयोजित करना शुरू कर सकते हैं और आवश्यक कार्यक्षमता का कार्यक्रम प्राप्त कर सकते हैं। नतीजतन, आप एक कार्यक्रम प्राप्त कर सकते हैं जो 355 को 113 से विभाजित करता है (या 16 बिट्स के भीतर एक दूसरे के ऊपर कोई अन्य संख्या)

फ्लोटिंग पॉइंट प्रोग्राम

 class Memory { public: Memory() { memset(m_mem, 0, sizeof(m_mem)); memPtr = 0; } Memory& operator += (uint16_t ptr) { memPtr += ptr; return *this; } Memory& operator -= (uint16_t ptr) { memPtr -= ptr; return *this; } uint16_t& operator [] (uint16_t ptr) { return this->m_mem[ptr]; } Memory& operator = (uint16_t ptr) { memPtr = ptr; return *this; } uint16_t & operator * () { return m_mem[memPtr]; } Memory& operator ++ () { memPtr++; return *this; } Memory& operator -- () { memPtr--; return *this; } private: uint16_t memPtr; uint16_t m_mem[65536]; }; void calcPi() { Memory mem; *mem = 22; mem += 1; *mem = 7; while (*mem) { mem += 1; (*mem)++; mem -= 1; (*mem)--; mem += 2; (*mem)++; mem -= 2; }//correct -909 while (*mem) { (*mem)--; } mem -= 1; while (*mem) { mem += 2; while (*mem) { mem += 4; (*mem)++; mem -= 4; (*mem)--; } mem += 4; while (*mem) { (*mem)--; mem -= 4; (*mem)++; mem -= 2; (*mem)--; if (!*mem) { //JZ out goto out; } mem += 6; } mem -= 6; out: mem += 6; if (*mem) { while (*mem) { mem -= 6; (*mem)++; mem += 6; (*mem)--; } mem -= 6; if (*mem) goto out1; } mem -= 5; (*mem)++; mem -= 1; } out1: mem += 10; *mem += 0x50;//P putc(*mem, stderr); *mem += 0x19;//i putc(*mem, stderr); *mem -= 0x2C;//= putc(*mem, stderr); mem -= 9; *mem += 0x30; putc(*mem, stderr); mem += 9; *mem -= 0xf; putc(*mem, stderr); mem -= 10; *mem += 6; while (*mem) { (*mem)--; mem += 1;//mem == 1 //nullCell(mem); while (*mem) { (*mem)--; } mem += 1; //mulConst(mem, 1, 10); while (*mem) { (*mem)--; mem -= 1; (*mem) += 10; mem += 1; } mem += 1; //addCpy(mem, 1, 2); while (*mem) { mem += 1; (*mem)++; mem -= 1; (*mem)--; mem += 2; (*mem)++; mem -= 2; } mem += 3; //nullCell(mem); while (*mem) { (*mem)--; } mem -= 5; while (*mem) { mem += 4; while (*mem) { mem += 6; (*mem)++; mem -= 6; (*mem)--; } mem += 6; while (*mem) { (*mem)--; mem -= 6; (*mem)++; mem -= 4; (*mem)--; if (!*mem)//,  ,      { goto out2; } mem += 10; } mem -= 10; out2: mem += 10; if (*mem) { //addMov(mem, -(6+ 4)); while (*mem) { mem -= 10; (*mem)++; mem += 10; (*mem)--; } mem -= 10; if (*mem) goto out3; } mem -= 5; (*mem)++; mem -= 5; } out3: mem += 4; while (*mem) { mem -= 3; (*mem)++; mem += 3; (*mem)--; } mem += 1;//mem == 6 *mem += 0x30; putc(*mem, stderr); mem += 1;//mem == 7 while (*mem) { (*mem)--; } mem -= 3; while (*mem) { mem -= 1; (*mem)++; mem += 1; (*mem)--; } mem -= 4;// mem == 0 } *mem += 0x0a; putc(*mem, stderr); *mem += 3; putc(*mem, stderr); }

रिले कंप्यूटर आर्किटेक्चर

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

इसलिए, मैं अनुकूलित ब्रेनफॉक ++ ऑपरेशन कर सकता हूं, और साथ ही कार्यक्रम के किसी भी पक्ष पर पूर्ण सशर्त कूदता हूं - जंप इफ जीरो और जंप इफ नॉट जीरो।

समन ऑपरेशन का परिणाम वर्तमान डेटा सेल की संख्या के साथ संदर्भ एपी - एपी - या में से किसी एक पर अपलोड किया जा सकता है, वर्तमान निर्देश की संख्या के साथ। इसके अलावा, परिणाम वर्तमान रैम सेल में अपलोड किया जा सकता है, अगर यह निर्देश + और - पर आता है

चित्र 4: संचालन में रिले कंप्यूटर वास्तुकला। नए निर्देश को लोड करने के चरण को इसके निष्पादन के चरण से बदल दिया जाता है।

सबसे पहले, हमें अगले निर्देश की संख्या की गणना करने की आवश्यकता है - अर्थात। IP ++ ऑपरेशन करें। ऐसा करने के लिए, एक को आईपी रजिस्टर के पुराने मूल्य में जोड़ा जाता है, परिणाम वापस आईपी रजिस्टर में लिखा जाता है, और अगला निर्देश सीएमडी रजिस्टर में इस नए पते पर लोड किया जाता है।

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

बग नहीं, बल्कि एक सुविधा

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

खाली निर्देशों का पालन करें और ... IP ++ करें!

नतीजतन, कार्यक्रम के शून्य मेमोरी सेल में शून्य होता है और इसे कभी भी निष्पादित नहीं किया जाएगा। मेमोरी से लोड किया गया पहला निर्देश 0x0001 पर इंस्ट्रक्शन होगा।

निर्देश सेट

चित्र 5: रिले कंप्यूटर अनुदेश सेट

निर्देश 16-बिट हैं, जहां 4 उच्च-क्रम बिट्स निर्देश के प्रकार के लिए जिम्मेदार हैं और निम्न-क्रम 12 बिट्स पेलोड हैं। ज्यादातर मामलों में यह एक स्थिर है।

एनओपी निर्देश - नजरअंदाज कर दिया।
CTRLIO निर्देश एक विशेष निर्देश है जिसका व्यवहार पेलोड बिटमास्क द्वारा एन्कोड किया गया है। सबसे पहले, यह कंसोल पर लिखने और कंसोल से पढ़ने के लिए आदेशों को लागू करता है (समकालिक या अतुल्यकालिक मोड में)। दूसरे, यह आपको मशीन के संचालन के 16-बिट या 8-बिट मोड को सेट करने की अनुमति देता है। और तीसरा, CTRLIO.HALT निर्देश का उपयोग करके, आप मशीन को रोक सकते हैं। मजेदार बात यह है कि मुखौटा बिट्स
गैर अवरुद्ध। आप उन्हें कम से कम एक बार में सेट कर सकते हैं, लेकिन मशीन का व्यवहार अपरिभाषित होगा।
ADD निर्देश एक डेटा सेल ऑपरेशन है। स्थिरांक के मान से सेल में मान को बदलता है। इस स्थिति में, बिट 12 एक हस्ताक्षरित बिट है और इसे 13-15 बिट्स में कॉपी किया जाता है। इसलिए, निर्देश 0x2ffe ऑपरेशन * AP + = 0x0ffe में बदल जाता है, और निर्देश 0x3ffe * AP + = 0xfffe में बदल जाता है। घटाव ऑपरेशन को ऋणात्मक संख्या के साथ बदल दिया जाता है।
एडीए निर्देश - ऑपरेशन एपी + = कास्ट को लागू करता है और आपको मेमोरी के माध्यम से नेविगेट करने की अनुमति देता है।
निर्देश JZ और JNZ सशर्त हैं। जेड-ध्वज के आधार पर, आप या तो कुछ निर्देशों को आगे या पीछे कूद सकते हैं, या जगह पर रह सकते हैं। मशीन के ऑपरेटिंग मोड के आधार पर - 16 या 8 बिट्स, जेड-ध्वज की स्थिति या तो कम से कम महत्वपूर्ण डेटा बाइट या पूरे शब्द द्वारा निर्धारित की जाती है।

तकनीकी विनिर्देश

BrainfuckPC एक रीड रिले प्रोसेसर, वॉन न्यूमैन आर्किटेक्चर और ब्रेनफैक ++ के साथ 16-बिट कंप्यूटर है।

रिले की कुल संख्या: 578 टुकड़े
तर्क तत्वों की कुल संख्या: 157 टुकड़े
पता बस की चौड़ाई: 16 बिट्स
संबोधन: शब्द द्वारा शब्द
RAM: 128KB (64 Kslov)
डेटा बस चौड़ाई: 16bit / 8bit
घड़ी की आवृत्ति (वर्तमान / अधिकतम): 25 हर्ट्ज / 40 हर्ट्ज
बिजली की खपत: 70 डब्ल्यू
समग्र आयाम: 110kh650kh140 मिमी
वजन: 15 किलो

प्रारंभ में, यह माना जाता था कि कंप्यूटर 100 हर्ट्ज तक की आवृत्ति पर काम करेगा ... और यह - एक मिनट के लिए - 4 पियानो ऑक्टेव्स। दुर्भाग्य से, पहले परीक्षणों से पता चला कि 40Hz छत है, लेकिन रिले सर्किट के लिए इसमें बहुत कुछ है। जब बाहरी घड़घड़ाहट प्रति चक्र दो दालों को लागू करने के लिए आवश्यक होती है, तो बाहरी संकेत के साथ सिंक्रोनाइज़ेशन सर्किट की ख़ासियत के कारण। संगीत के लिए 80 हर्ट्ज पहले से ही कुछ है।

कंप्यूटर रचना

चित्र 6: रिले कंप्यूटर के मुख्य घटक।

आइए कंप्यूटर पर करीब से नज़र डालें। मशीन की लगभग पूरी मात्रा रिले प्रोसेसर इकाइयों द्वारा कब्जा कर ली गई है। फिलहाल, सब कुछ पांच ब्लॉकों में फिट बैठता है, लेकिन छह के लिए जगह है - इसलिए यदि आप वास्तव में चाहते हैं, तो बाद में प्रोसेसर की कार्यक्षमता का विस्तार किया जा सकता है।
इस तरह के प्रत्येक ब्लॉक में 32 मॉड्यूल होते हैं, प्रत्येक मॉड्यूल में 3 या 4 रीड रिले RES55 और RES64 होते हैं। प्रत्येक इकाई की बिजली आपूर्ति 5 वी, 3 ए है।

अंजीर। 7: एक फ्रेम पर स्थापना के लिए तैयार रिले प्रोसेसर के ब्लॉक और मॉड्यूल का एक सेट।

प्रत्येक मॉड्यूल एकीकृत है। 60x44 मिमी, 16-पिन कनेक्टर। तर्क ब्लॉकों को इकट्ठा करते समय, मैंने आवश्यक मॉड्यूल को एक मुफ्त स्लॉट में डाला और कनेक्शन को फ्लैश किया।

अंजीर। 8: डी-फ्लिप-फ्लॉप मॉड्यूल को संचालन के लिए जांचा जाता है।

केंद्रीय पंक्ति - योजक ब्लॉक और रजिस्टर ब्लॉक। ऊपर और नीचे RES43 पर आधारित 16-बिट लैच हैं, जो ब्लॉक के बीच डेटा प्रवाह को स्विच करते हैं। सारा डेटा यहां घूम रहा है।

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

अंजीर। 9: फ्रेम को 2 मिमी एल्यूमीनियम शीट से, लेजर कटिंग के नीचे से इकट्ठा किया गया है। तस्वीर में - पहले से ही वेल्डेड और प्राइमेड फ्रेम, पेंटिंग के लिए तैयार।

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

चित्र 10: संकेतक क्षेत्र का अंतिम दृश्य। विनिर्माण प्रक्रिया में।

दाईं ओर मेमोरी कार्ड है - मशीन का सबसे विवादास्पद तत्व। हालांकि मेरा मानना है कि कंप्यूटर अभी भी रिले है, प्रोसेसर निश्चित रूप से 100% रिले है। परिधि अधिक आधुनिक है। विशेष रूप से, रैम एक स्थिर मेमोरी चिप है। लेकिन इसलिए रिले कंप्यूटर के लगभग सभी आधुनिक निर्माता हैं।

चित्र 11: प्रोग्रामर। 16 पता लाइनें, 16 डेटा लाइन, पावर, ग्राउंड और रीड लाइन लिख सकते हैं। कुल 36 संपर्क।

चूंकि प्रोग्राम और डेटा की मेमोरी साझा की जाती है, कोई या कुछ, हर बार जब आप कंप्यूटर चालू करते हैं, तो प्रोग्राम को रैम में लोड करना होगा। यह कार्य प्रोग्रामर को सौंपा गया है। फिलहाल, प्रोग्रामर मेमोरी बोर्ड पर ही स्थित है। अब उसके पास ठीक दो काम हैं।

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

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

अंजीर। 12: प्रोसेसर बाह्य उपकरणों के ब्लॉक आरेख।

तो निकट भविष्य में प्रोसेसर बाह्य उपकरणों के सर्किट्री की तरह दिखेगा। केवल मेमोरी चिप्स और रिले सर्किट के साथ सिग्नल मिलान सर्किट मेमोरी बोर्ड पर बने रहेंगे।

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

नतीजतन, रिले लॉजिक एक निश्चित इंटरफ़ेस प्रदान करता है, और इंटरफ़ेस कनवर्टर कोई भी हो सकता है। वैसे, समानांतर इंटरफ़ेस कनेक्टर LPT के साथ संगत होगा ...

कार्य और वर्तमान स्थिति का प्रदर्शन

सबसे पहले, कंप्यूटर पर विकिपीडिया लेख से हैलो वर्ल्ड प्रोग्राम निष्पादित किया गया था।

स्रोत कोड इस प्रकार है:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.

एलईडी पैनल के लिए धन्यवाद, आप स्पष्ट रूप से देख सकते हैं कि डेटा कैसे बदलता है:

हालांकि 25 हर्ट्ज की आवृत्ति पर रैम में क्या हो रहा है, इसका ट्रैक रखना मुश्किल है।

दशमलव बिंदु के बाद संख्या पाई के संकेतों की गणना करने के लिए एक अधिक उपयोगी और व्यावहारिक कार्य है। यह स्पष्ट है कि आधुनिक कंप्यूटरों ने इस समस्या को 31.4 ट्रिलियन वर्णों तक हल किया है। लेकिन यह तथ्य कि ब्रेनफकपीसी इस ऑपरेशन को करने में सक्षम है, यह बताता है कि रिले कंप्यूटर 100% बेकार नहीं है, बल्कि केवल 99.9 है।

सबसे पहले, मुझे एक तैयार-तैयार गणना एल्गोरिदम मिला जो ब्रेनफॉक में लिखा गया था ।

> ++++ (4 digits)
[<+>>>>>>>>++++++++++<<<<<<<-]>+++++[<+++++++++>-]+>>>>>>+[<<+++[>>[-<]<[>]<-]>>
[>+>]<[<]>]>[[->>>>+<<<<]>>>+++>-]<[<<<<]<<<<<<<<+[->>>>>>>>>>>>[<+[->>>>+<<<<]>
>>>>]<<<<[>>>>>[<<<<+>>>>-]<<<<<-[<<++++++++++>>-]>>>[<<[<+<<+>>>-]<[>+<-]<++<<+
>>>>>>-]<<[-]<<-<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+<<<-[>>+<<-]<]<<<<+>>>>>>>
>[-]>[<<<+>>>-]<<++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+>[<<+<+>>>-]<<<
<+<+>>[-[-[-[-[-[-[-[-[-<->[-<+<->>]]]]]]]]]]<[+++++[<<<++++++++<++++++++>>>>-]<
<<<+<->>>>[>+<<<+++++++++<->>>-]<<<<<[>>+<<-]+<[->-<]>[>>.<<<<[+.[-]]>>-]>[>>.<<
-]>[-]>[-]>>>[>>[<<<<<<<<+>>>>>>>>-]<<-]]>>[-]<<<[-]<<<<<<<<]++++++++++.

एक समस्या - हालांकि यह कहा जाता है कि यह कार्यक्रम किसी अन्य कार्यक्रम की तुलना में बहुत तेज है, यह अभी भी अगले चरित्र की गणना करता है, यह बेहद धीमी है।

चित्र 13: दशमलव बिंदु के बाद पाई के एन अंकों को आउटपुट करने में लगने वाला समय।

4 दशमलव स्थानों पर लगभग डेढ़ घंटे इंतजार करना होगा ...

चित्र 14: - पाई = 3! - कैसे अशिष्ट!

हालांकि, यहां तक कि दो अक्षर भी वास्तव में कटौती करने में सक्षम नहीं थे, इसके बजाय, कंप्यूटर ने कहा कि पाई 4 थी और उसने काम पूरा किया।

चित्र 15: वह मजाक के बारे में स्पष्ट रूप से जानता है कि मार्शल लॉ के तहत, पीआई चार तक जा सकती है।

मैंने दूसरे रास्ते पर जाने का फैसला किया और एक अंश कैलकुलेटर लिखा

f r a c 355113 = 3.141592 . . .

$\ frac {355} {113} = 3.141592 ...$ । सटीकता - 6 दशमलव स्थान! यह पर्याप्त आकार की संख्या के साथ अंशों के लिए सबसे सटीक परिणाम है।

तीन रातों की नींद हराम करने के बाद, मैंने ब्रेनफॉक पर एक प्रोग्राम लिखा, जो दो नंबरों को एक दूसरे में विभाजित करने और टर्मिनल के फ्लोटिंग पॉइंट के साथ परिणाम को आउटपुट करने में सक्षम था। एमुलेटर का फैसला इस प्रकार है - इसे निष्पादित करने के लिए 60 हजार निर्देश होंगे। आखिरी में, प्रति साइन 10 हजार:

अंजीर। 16: अंश की गणना करते समय अगले दशमलव स्थान के उत्पादन में लगने वाला समय।

अगले मूल्य कितनी जल्दी दिखाई देंगे। मुझे पिछले कार्यक्रम की तुलना में बहुत जल्दी कहना चाहिए!

लेकिन खुशी अल्पकालिक थी - कंप्यूटर 16-बिट मोड में विफल होने लगा। डायग्नोस्टिक्स ने दिखाया कि मेमोरी कार्ड बेवकूफ बना रहा है - यह लगातार 13 वें बिट को सेट करता है। मैं एक नया मेमोरी कार्ड बनाऊंगा और सब कुछ बीत जाएगा, लेकिन अब मैं खुद को एक अंश तक सीमित करूंगा

f r a c 227 = 3.14 . . .

$\ frac {22} {7} = 3.14 ...$ दो दशमलव स्थान और ऑपरेशन के 8 बिट मोड। सबसे महत्वपूर्ण बात, यह केवल 1,600 निर्देशों का पालन करने की आवश्यकता है! 25 हर्ट्ज की आवृत्ति पर, यह सिर्फ एक मिनट से अधिक है।

बार-बार और एक सीटी के साथ, कंप्यूटर कार्य के साथ मुकाबला करता है।

जारी रखने के लिए ...

अब कंप्यूटर पर आप ऐसे प्रोग्राम चला सकते हैं जिनमें उपयोगकर्ता इनपुट की आवश्यकता नहीं है। अब तक, मैंने CTRLIO.CIN निर्देश पर तुच्छ रूप से पेंच नहीं डाला है :) और मैं जल्द ही ऐसा करने वाला नहीं हूं। वर्तमान में कंप्यूटर 98% पूर्ण है। और दो साल के काम के बाद, कई परियोजनाएं जमा हो गई हैं जो उस समय की प्रतीक्षा कर रही हैं जब मैं उनसे निपटूंगा।

इसलिए, मैं अन्य परियोजनाओं पर स्विच करता हूं

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

मैंने इसके लिए एक मेमोरी तैयार की है - प्रत्येक 16-बिट शब्दों के लिए एकीकृत मेमोरी क्यूब्स के 16 टुकड़े । अंदर - मल्टी-होल फेराइट प्लेट, फेराइट रिंग पर एक प्रकार की मेमोरी शाखा।

मैं या तो निमोनिया के बारे में नहीं भूलता - मेरे दोस्त एंटोन प्रकृति में लगे हुए हैं। प्रयोग, लेकिन अगली बार उस पर अधिक।

... निम्नलिखित खामियों को छोड़कर। मैं मई के अंत में त्योहार के लिए समस्या का हिस्सा हल करूंगा, भाग - नहीं:

एक नया मेमोरी कार्ड जिस पर केवल रैम चिप्स और उनके हार्नेस स्थापित हैं। मेमोरी कार्ड के लिए एक सर्किट बोर्ड है; सर्किट बोर्ड अभी तक तलाकशुदा नहीं है। घर पर, यह करने के लिए बहुत आलसी होगा (एक काफी घना दो-तरफा), इसलिए मैं इस बोर्ड को उस क्रम में शामिल करूंगा जब मैं कुछ अन्य परियोजनाओं के लिए बोर्ड का आदेश दूंगा - एक रिले और एक न्यूमोस्कोप पर एक यांत्रिक घड़ी।
नए मेमोरी बोर्ड के साथ, डायल संकेतक, सामान्य टर्मिनल डिस्प्ले हार्डवेयर और एलईडी पैनल को अपडेट करने के लिए स्वतंत्र तर्क आएंगे।
प्रोग्रामर, या बल्कि, इसके लिए फर्मवेयर का विकास। सामान्य तौर पर, यदि आपके पास एक पुराना मेमोरी कार्ड है, तो यह बेमानी है, लेकिन चूंकि प्रोग्रामिंग कनेक्टर उपलब्ध है, इसलिए आप पहले से ही इस पर प्रोग्राम लोड कर सकते हैं।
समय का तर्क। यहां मैं पूरी तरह से आलसी गधा हूं, क्योंकि शाब्दिक रूप से 3 तार्किक मॉड्यूल हैं। मई के अंत में त्योहार के लिए मैं निश्चित रूप से ऐसा करूंगा।
कंसोल से निर्देश पढ़ना। यह टाइमिंग के तर्क से जुड़ा हुआ है (तुल्यकालिक ऑपरेशन में, कंप्यूटर को ऑपरेशन बंद करना होगा और डेटा आने का इंतजार करना होगा)।
गिनीज़ बुक ऑफ़ रिकॉर्ड्स में एक अनुरोध भेजें ... सबसे तेज़ रिले प्रोसेसर के रूप में और उसी समय सबसे धीमा पढ़ने वाला। 16 milliFlops आपके लिए नहीं है ("फर कोट इन अंडरपैंट्स में टक" (यूट्यूब पर टिप्पणियों से)।

रिले कंप्यूटर पर सभी दस्तावेज GitHub पर रिपॉजिटरी में हैं , और आप मेरी प्रोफाइल में लिंक का उपयोग करके किसी भी सामाजिक नेटवर्क पर इसकी स्थिति की निगरानी कर सकते हैं।

UPD: मैंने उत्सव में भाग लेने से इनकार कर दिया।
और फिर भी - 25-26 मई को, मॉस्को में, ब्रेड फैक्टरी के क्षेत्र पर, शिल्प प्रस्तुतियों और DIY संस्कृति एंटिफैक्ट्री का पहला उत्सव आयोजित किया जाएगा। मैं एक रिले कंप्यूटर के साथ वहां मौजूद रहूंगा और मैं ऑटॉटरिंग के लिए एक रिले नियंत्रक भी लाऊंगा । घटना के लिए प्रवेश नि: शुल्क है, इसलिए आप इन दिनों मास्को में होंगे - मेरे रिले राक्षस को लाइव देखने का मौका न चूकें। अगर मैं इसे सुरक्षित और मजबूत बनाकर लाता हूं, तो मैं निश्चित रूप से इसे काम में प्रदर्शित करूंगा।

माई लिटिल रिले: ट्रिपल ब्रेनफक, या व्हाट इज़ पागलपन