कोड में सत्य सारणी? राज्य मशीन की संरचना कैसे करें?

Question

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

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

मैं सोच रहा था मैं बहुत तरह मेरे सच तालिका को एक्सेस करना चाहते हैं:

u8 newState[] = decisionTable[input1][input2][input3][input4]; 

और फिर मैं के साथ उत्पादन मूल्यों पहुंच सकता है:

setOutputPin(LINE_0, newState[0]); 
setOutputPin(LINE_1, newState[1]); 
setOutputPin(LINE_2, newState[2]); 
setOutputPin(LINE_3, newState[3]); 

लेकिन उस पाने के लिए आदेश में यह, ऐसा लगता है कि मुझे एक बिल्कुल भ्रमित करने वाली टेबल करना होगा:

static u8 decisionTable[][][][][] = 
{{{{ 0, 0, 0, 0 }, 
    { 0, 0, 0, 0 }}, 
    {{ 0, 0, 0, 0 }, 
    { 0, 0, 0, 0 }}}, 
    {{{ 0, 0, 1, 1 }, 
    { 0, 1, 1, 1 }}, 
    {{ 0, 1, 0, 1 }, 
    { 1, 1, 1, 1 }}}}, 
{{{{ 0, 1, 0, 1 }, 
    { 1, 1, 1, 1 }}, 
    {{ 0, 1, 0, 1 }, 
    { 1, 1, 1, 1 }}}, 
    {{{ 0, 1, 1, 1 }, 
    { 0, 1, 1, 1 }}, 
    {{ 0, 1, 0, 1 }, 
    { 1, 1, 1, 1 }}}}; 

उन नेस्टेड ब्रैकेट्स सीए n कुछ हद तक भ्रमित हो रहा है - क्या किसी के पास एक बेहतर विचार है कि मैं अपने कोड में एक सुंदर दिखने वाली तालिका कैसे रख सकता हूं?

धन्यवाद!

संपादित HUAGHAGUAH के उत्तर के आधार पर:

हर किसी के इनपुट की एक समामेलन का उपयोग करना (धन्यवाद - काश मैं "स्वीकार" कर सकता है 3 या इन उत्तरों की 4), मुझे लगता है कि मैं इसे करने की कोशिश करने जा रहा हूँ एक दो आयामी सरणी के रूप में। मैं हूँ मेरी सरणी एक छोटा-सा बदलने मैक्रो का उपयोग में सूचकांक:

#define SM_INPUTS(in0, in1, in2, in3) ((in0 << 0) | (in1 << 1) | (in2 << 2) | (in3 << 3)) 

और वह मेरी सच्चाई तालिका सरणी इस तरह दिखना दूँगी:

static u8 decisionTable[][] = { 
{ 0, 0, 0, 0 }, 
{ 0, 0, 0, 0 }, 
{ 0, 0, 0, 0 }, 
{ 0, 0, 0, 0 }, 
{ 0, 0, 1, 1 }, 
{ 0, 1, 1, 1 }, 
{ 0, 1, 0, 1 }, 
{ 1, 1, 1, 1 }, 
{ 0, 1, 0, 1 }, 
{ 1, 1, 1, 1 }, 
{ 0, 1, 0, 1 }, 
{ 1, 1, 1, 1 }, 
{ 0, 1, 1, 1 }, 
{ 0, 1, 1, 1 }, 
{ 0, 1, 0, 1 }, 
{ 1, 1, 1, 1 }}; 

और मैं तो जैसे मेरी सच्चाई तालिका का उपयोग कर सकते इसलिए:

decisionTable[ SM_INPUTS(line1, line2, line3, line4) ] 

मैं इसे एक शॉट दूंगा और देखें कि यह कैसे काम करता है। मैं 0 और 1 के साथ और अधिक सहायक # डिफाईन्स को प्रतिस्थापित कर दूंगा जो प्रत्येक राज्य का अर्थ है/**/टिप्पणियों के साथ जो आउटपुट की प्रत्येक पंक्ति के लिए इनपुट की व्याख्या करता है। सहायता के लिए हर किसी को धन्यवाद!

Answer 1

एक बहुआयामी तालिका की आवश्यकता नहीं है। 4 बिट => 4 बिट मैपिंग के साथ, आपके पास आउटपुट में एक एकल u8 [16] सरणी मैपिंग इनपुट हो सकता है। राज्य लुकअप बहुत सस्ता हो जाएगा, और आप कुछ शिफ्ट-एंड-मास्क ऑप्स के साथ अलग-अलग बिट्स निकाल सकते हैं।

यदि पंक्तियों को पॉप्युलेट करने के लिए एल्गोरिदम कोडोड करना आसान है, तो आप प्रत्येक पंक्ति को सूचकांक संख्या द्वारा पॉप्युलेट करने के लिए एक मैक्रो परिभाषित कर सकते हैं।

Answer 2

व्यक्तिगत रूप से, मैं इसे एक कॉन्फ़िगरेशन फ़ाइल से पढ़ता हूं। सीएसवी, शायद, जो एक्सेल से निर्यात करना आसान है। या आप एक्सेल से सादा पाठ में कॉपी और पेस्ट कर सकते हैं, जो आपको स्पेस से अलग मूल्य देता है, जो आयात करने के लिए समान रूप से आसान है।

इसका यह भी अर्थ है कि आप सी के साथ काम कर रहे हैं, कि निर्णय तालिका में हर बार आपको अपना कोड दोबारा नहीं करना पड़ेगा।

Answer 3

मैं या तो (पसंदीदा दृष्टिकोण पहले) का सुझाव चाहते हैं:

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

Answer 4

यदि आपकी सच्चाई तालिका सभी बुलियन है, तो आप इसे जोड़ों की सूची में संक्षिप्त कर सकते हैं, उदा।

1111,0000 
1110,0110 
... 

डेटा संपीड़न के लिए

, बाइट (दो nybbles) के रूप में मूल्यों का प्रतिनिधित्व ...

जहां/कैसे अपने विशेष एम्बेडेड सिस्टम विन्यास में मुलायम-कोडिंग के लिए यह स्टोर करने के लिए, केवल आप कह सकते हैं; -)

Answer 5

यदि सत्य तालिका वास्तव में केवल 4x4x4x4 है तो मैं मैक्रोज़ का उपयोग करूंगा। यदि यह कभी भी बढ़ने जा रहा है, तो मैं Ragel का उपयोग करूंगा। संभावना है कि यह आपके से छोटे, तेज़ सी कोड बनाएगा।

Answer 6

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

Answer 7

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