डिजिटल लॉजिक में सेट बिट्स की संख्या प्राप्त करें

Question

एक अभ्यास के रूप में, मैं कॉनवे के गेम ऑफ लाइफ को सरल डिजिटल लॉजिक में लागू करने की कोशिश कर रहा हूं। मैं एक 9-चर समारोह को कम करके पूरी बात कर सकता था, लेकिन मुझे लगता है कि अभी भी काफी बड़ा होगा। एल्गोरिथ्म के मुख्य तत्वों में से एक यह निर्धारित कर रहा है कि आपके 8 पड़ोसियों में से कितने 'जीवित' हैं।

8 इनपुट को देखते हुए, यह निर्धारित करने का सबसे आसान तरीका है कि कितने सेट हैं? विशेष रूप से मुझे एक आउटपुट की आवश्यकता है जो 2 सेट होने पर उच्च है, और एक आउटपुट जो 3 सेट होने पर उच्च है।

मेरा मुख्य विचार अब एक पीआईएसओ शिफ्ट रजिस्टर, एक काउंटर, और एक 3: 8 डिकोडर का है, लेकिन मुझे उस सभी को चलाने के लिए एक माइक्रोकंट्रोलर की बहुत आवश्यकता है। ऐसा लगता नहीं है कि किसी फ़ंक्शन का यह जटिल है। शायद एक 256x2 रोम भी काम करेगा, लेकिन मेरी खोजों ने उस तरह के किसी भी हिस्से को चालू नहीं किया है।

मुझे पता है कि 10 आईओ के साथ कोई भी तस्वीर यह तुच्छ तरीके से कर सकती है, लेकिन मैं इसे यथासंभव न्यूनतम तरीके से लागू करना चाहता हूं।

Answer 1

आपको Fast Bit Counting enlightening पर विभिन्न एल्गोरिदम मिल सकते हैं । आखिरी दो: निफ्टी पैरेलल काउंट और MIT HAKMEM काउंट को गेट्स में बदलना आसान हो सकता है। यह कैसे काम करता है की एक अच्छी व्याख्या के लिए इस पृष्ठ को देखें ।

आप गेट्स हार्डवेयर का उपयोग करके ऐसा कर सकते हैं। बिट्स के जोड़े को एक साथ जोड़ने के लिए चार 1-बिट योजक का उपयोग करें। इससे आपको चार 3-बिट नंबर मिलते हैं। दो 3-बिट योजक का उपयोग करके इन जोड़े में जोड़ें। यह आपको एकल 4-बिट योजक का उपयोग करने के लिए दो 4-बिट संख्या देता है। यह आपको 5-बिट मान के साथ छोड़ता है, लेकिन आप शीर्ष बिट को अनदेखा कर सकते हैं। फिर मान 2 और 3 के परीक्षण के लिए दो 4-बिट तुलनित्र का उपयोग करें।

न्यूनतम भागों की गणना के लिए, यह एनालॉग क्यों नहीं?

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

8-रोकनेवाला नेटवर्क 0v (0-बिट सेट के लिए) से 5v (8 बिट सेट के लिए) के बीच एक वोल्टेज का उत्पादन करेगा। 2 बिट्स 0.5v का उत्पादन करेंगे। 3 बिट्स 1.56v का उत्पादन करेंगे।

• 0 या 1 बिट्स के साथ, आउटपुट 00 होगा।
• 2 या 3 बिट्स के साथ, आउटपुट 01 होगा।
• 4 या अधिक बिट्स के साथ, आउटपुट 11 होगा।

---

जोड़ा गया:

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

अच्छी बात यह है कि इस सर्किट में अन्य सर्किट की तुलना में केवल दो और घटक हैं। वे सभी E8 श्रृंखला प्रतिरोधक हैं, इसलिए पकड़ना संभव होना चाहिए। साथ ही, R6 का मान उच्च होना चाहिए, जैसे 4.7k या कुछ और।

Comments

+1 केवल इसलिए कि आपका उत्तर "एक माइक्रोकंट्रोलर का उपयोग करें" नहीं है । ऐसा लगता है कि यह डिफ़ॉल्ट मोड है।

— कॉनर वुल्फ

@ फ़ेकनाम: पहला संदर्भ सॉफ़्टवेयर समाधानों का है। बेशक आपको उन्हें माइक्रोकंट्रोलर पर लागू करने की आवश्यकता नहीं है, आप सुपरकंप्यूटर का उपयोग भी कर सकते हैं :)

— फेडेरिको रूसो

@FedericoRusso - मैंने सॉफ्टवेयर सॉल्यूशन के लिए उन संदर्भों को दिया, जो कुछ अंतर्दृष्टि देते हैं कि कैसे वे इसे हार्डवेयर में लागू कर सकते हैं।

— रॉकेटमैग्नेट

शायद: केंद्रीय कक्ष की वर्तमान स्थिति से 20 kOhm के 9 वें "समकालिक अवरोधक" को जोड़कर Rocketmagnet के सर्किट में "+" योग बिंदु - अर्थात, केंद्रीय सेल को 1 और 8 स्कोरिंग कोशिकाओं का भार दें। 2 का वजन। फिर वोल्टेज विभक्त को "जन्म" (3 जीवित पड़ोसियों के साथ केंद्रीय मृत सेल; योग = 6) और "जीवित रहें" (2 या 3 जीवित पड़ोसियों के साथ जीवित केंद्रीय मृत कोशिका), योग = 5 या 7) "01" का आउटपुट देता है; और अन्य सभी मामले (जहां केंद्रीय सेल मर जाता है या मृत हो जाता है) "00" या "11" का आउटपुट देते हैं। फिर एक XOR गेट केंद्रीय सेल की अगली स्थिति देता है।

— दाविदरी

Ive ने कुछ प्रयोग करते हुए पाया: प्रतिरोध बहुत सही नहीं हैं। मुझे कुछ बेहतर संयोजन मिले लेकिन मैं अभी भी अनुकूलन करने की कोशिश कर रहा हूं। इसके अलावा, जब इनमें से एक ग्रिड बनाते हैं, तो समिमिग प्रतिरोधों के माध्यम से पीछे की ओर प्रवाह होगा और चीजों को गड़बड़ कर देगा। इंटरलिंक पर डायोड इसे रोकने का एक तरीका है।

— captncraig

Answer 2

न्यूनतम क्या है? माइक्रो सिर्फ 1 हिस्सा है, और कम से कम देरी से परिणाम का उत्पादन कर सकते (<1 रों)। 54 प्रतिशत एटीटीइन 20 डिजीकाइ में 10 आई / ओ के साथ सबसे सस्ता माइक्रोकंट्रोलर है। $\mu$

लुकअप टेबल भी सिर्फ 1 हिस्सा है, और माइक्रोकंट्रोलर की तुलना में तेज़ है। समानांतर EEPROM के बारे में भूल जाओ, वे महंगे हैं। बाइट-वाइड समानांतर फ़्लैश का उपयोग करें । यह एक 512 kByte है, जो कि आपकी ज़रूरत से 2000 गुना अधिक है, लेकिन यह सबसे सस्ता समाधान (1 डॉलर) है। और आप एक ही कीमत के लिए 6 और 1-बिट फ़ंक्शंस जोड़ सकते हैं।

आप CPLD का उपयोग भी कर सकते हैं । VHDL या वेरिलॉग में फ़ंक्शन को एक लंबे एसओपी (उत्पाद के योग) के रूप में लिखें, और सिंथेसाइज़र को तर्क बनाने दें।

शिफ्ट रजिस्टर ठीक है अगर आप परिणाम के लिए प्रतीक्षा कर सकते हैं; यह सबसे धीमा समाधान है।

अंत में, आप इसे लॉजिक गेट्स के साथ कर सकते हैं , लेकिन यदि आप सभी बुनियादी जाना चाहते हैं, तो आपको एसओपी को कम से कम करने के लिए बहुत समय बिताना होगा। रॉकेटमैग्नेट को ऐडर्स का उपयोग करने का सही विचार है, लेकिन उसकी संख्या बंद है: एक 1 बिट आधा योजक 2 बिट्स देता है, न कि 3। इसलिए आधे योजक के आउटपुट को दो से जोड़कर दो 2-बिट आधे योजक की आवश्यकता होती है, दो 3- 3- थोड़ा परिणाम। 4-बिट परिणाम प्राप्त करने के लिए 3-बिट आधे योजक का उपयोग करें। 1-बिट पूर्ण योजक का उपयोग करके आपको केवल एक 2-बिट योजक की आवश्यकता होगी।

Answer 3

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

tempVal [x, y] = मूल [x-1, y] + मूल [x, y] + मूल [x + १, y] ’तीन-बिट संख्या के दो-बिट योग
उत्पत्ति [x, y] = LiveDeadFunc (मूल [x, y], टेम्पलेवल [x, y-1] + tempVal [x, y] + tempVal [x, y + १]]

सरणी tempVal[x,y]में प्रति सेल दो बिट्स हैं; बाद वाला ऑपरेशन 0-9 (हालांकि सभी मूल्य चार के बराबर हैं) का उत्पादन करने के लिए तीन ऐसी संख्याओं को एक साथ रखता है, जो तब अगली पीढ़ी के लिए एकल-बिट लाइव / डेड स्थिति की गणना करने के लिए उपयोग किया जा सकता है।

BTW, दूसरे चरण में एक अंकगणितीय योग करने और मूल्य की जांच करने का विकल्प tempVal [x, y] को एक-गर्म प्रतिनिधित्व में बदलना होगा, और फिर मूल्यों के नौ संयोजनों में से एक के लिए जाँच करें जो तीन उपज देगा कोशिकाएं, या बारह में से एक जो चार उपज होगी।