💃 🧛🏾 👁‍🗨 कैलकुलेटर प्रोग्रामिंग 👨‍🎨 🚳 🦈

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

कुछ समय पहले, मैंने अपनी पेंट्री में एक पुराना " इलेक्ट्रॉनिक्स एमके -61 " पाया, जो मेरे पिताजी का था। स्वाभाविक रूप से, मैं एक कैलकुलेटर पर काफी "मानक" प्रोग्रामिंग सीखने का ऐसा मौका नहीं छोड़ सका। (यदि आपके पास प्रोग्राम करने योग्य कैलकुलेटर नहीं है, तो आप यहां एमुलेटर डाउनलोड कर सकते हैं )

स्मृति

सबसे पहले, आपको यह समझने की आवश्यकता है कि इस कैलकुलेटर में मेमोरी कैसे काम करती है। उपयोगकर्ता के निपटान में 4 स्टैक रजिस्टर हैं: एक्स, वाई, जेड, टी। रजिस्टर एक्स की सामग्री हमेशा स्क्रीन पर दिखाई जाती है (गणना मोड में), संख्याओं का इनपुट भी इसमें जाता है। वास्तव में, कैलकुलेटर को चालू करने के बाद स्टैक मेमोरी इस तरह दिखती है:

T 0 Z 0 Y 0 X 0

स्टैक पर कुछ पुश करने के लिए, [↑]

कुंजी का उपयोग करें। यह Y को रजिस्टर करने के लिए रजिस्टर X की सामग्री की प्रतिलिपि बनाता है, रजिस्टर Y से Z, Z से T तक का मूल्य, और T में जो मूल्य था वह खो जाता है। अर्थात्, यदि रजिस्टरों में बटन [↑]

दबाने से पहले मान थे

 T 5 Z 8 Y 14,5 X 6

।

तब मूल्य बन जाएगा

 T 8 Z 14,5 Y 6 X 6

इसके अलावा, एक कमांड है जो आपको रजिस्टरों के सभी मूल्यों को Cyclically Shift करने की अनुमति देता है: T से Z, Z से Y, Y से X, X से T. ऐसा करने के लिए, [F] [.]

दबाएं।

[]

कमांड X और Y रजिस्टर की सामग्री को स्वैप करता है।

[CX]

कमांड X की सामग्री को मिटा देता है।

स्टैक मेमोरी के अलावा, कैलकुलेटर में 15 पता योग्य रजिस्टर (RG0-RGE) हैं। उनके साथ काम करने के लिए, चाबियाँ [X→]

और [→X]

। पहला कमांड रजिस्टर एक्स की सामग्री को संबंधित पते योग्य रजिस्टर में डालता है। उदाहरण के लिए, कमांड का क्रम [4] [X→] [0]

नंबर [4] [X→] [0]

रजिस्टर RG0 में नंबर 4 को रखता है। दूसरी कमांड, आपने यह अनुमान लगाया, पता योग्य रजिस्टर की सामग्री को रजिस्टर X पर कॉपी करता है। यह है, [→X] [0]

डाल देगा। X नंबर 4 है।

यह याद रखना महत्वपूर्ण है कि कैलकुलेटर बंद करने के बाद, सभी रजिस्टरों के मूल्य मिट जाते हैं।

बस्तियों

गणना शुरू करने से पहले आपको मुख्य बात यह जानना चाहिए कि MK-61 रिवर्स पोलिश नोटेशन (OPN) का उपयोग करता है। अगर हमें किसी भी अनियंत्रित ऑपरेशन को करने की आवश्यकता है, तो यह रजिस्टर एक्स में नंबर पर किया जाता है। इसी समय, अन्य रजिस्टरों के मूल्य नहीं बदलते हैं। बाइनरी ऑपरेशनों को रजिस्टरों Y और X (उस क्रम में) की सामग्री पर किया जाता है। परिणाम मान को X में रखा गया है, Z को Y में रखा गया है, T को Z से कॉपी किया गया है। रजिस्टर X के पिछले मूल्य को सेवा रजिस्टर X1 में रखा गया है। इस प्रकार, यदि हमें तुच्छ 2 + 3 (सर्ज अरेस्टर 2 3 + में) की गणना करने की आवश्यकता है, तो हमें कैलकुलेटर पर चाबियाँ दबाने की आवश्यकता है: [2] [↑] [3] [+]

। इस मामले में, रजिस्टरों के मूल्यों को निम्नानुसार बदला गया है:

सभी कार्यों से पहले:

 T 8 Z 14,5 Y 6 X 0

चाबियाँ दबाने के बाद [2] [↑] [3]

the [2] [↑] [3]

:

 T 14,5 Z 6 Y 2 X 3

दबाने के बाद [+]

:

 T 14,5 Z 14,5 Y 6 X 5

आइए, उदाहरण के लिए, (15 + 2/5) * 7 + 10. थोड़ी अधिक जटिल गणनाएँ आजमाएँ। इस अभिव्यक्ति को इस तरह लिखा जा सकता है: 15 2 5 / + 7 * 10 +। कैलकुलेटर पर यह गणना करने के लिए, हमें कुंजियों को दबाना होगा: [15] [↑] [2] [↑] [5] [/] [+] [7] [*] [10] [+]

calculate [15] [↑] [2] [↑] [5] [/] [+] [7] [*] [10] [+]

।

प्रोग्रामिंग

तो, ठीक है, यह और अधिक दिलचस्प है :)। प्रोग्रामिंग मोड में प्रवेश करने के लिए, [F] []

दबाएँ। 00 डिस्प्ले पर दिखाई देगा। इसका मतलब है वर्तमान कमांड संख्या। सामान्य तौर पर, एमके -61 में कार्यक्रम समस्या को हल करने के लिए आवश्यक आदेशों का एक क्रम है। आमतौर पर यह अंकगणितीय संचालन, संख्याएं, कभी-कभी लूप और शाखाओं के विशेष कोड होते हैं। कुल में, एक प्रोग्राम में 105 से अधिक कमांड नहीं हो सकते हैं, जो 00 से 99 तक गिने जाते हैं। कमांड में प्रवेश करने के लिए, संबंधित कुंजी दबाएं। यहाँ कोड और पत्राचार की कुंजी के पत्राचार की तालिका है:

प्रोग्रामिंग मोड में, दर्ज किए गए अंतिम 3 ऑपरेशन दिखाई दे रहे हैं। उदाहरण के लिए

02 01 0E 06

डिस्प्ले पर इसका मतलब है:

06

- दर्ज किए जाने वाले अगले कमांड का पता
0E, 01, 02

- तीन लगातार आदेश ०३, ०४, ०५, पते पर स्थित हैं।

मूल बातें

आइए हम सूत्र .r ² द्वारा एक वृत्त का क्षेत्रफल ज्ञात करने की सबसे सरल समस्या का विश्लेषण करें। इस समस्या को हल करने के लिए कैलकुलेटर के लिए, हम प्रोग्रामिंग मोड ( [F] []

) में निम्न कमांड पेश करते हैं (हम मानते हैं कि सर्कल का त्रिज्या RG1 रजिस्टर में है):

 //    —  ,    00 [→X] [1] //    RG1   X (61) 01 [F] [*] //     (22) 02 [F] [+] //   X  (20) 03 [*] //   X  Y (12) 04 [/] //     (    ) (50)

वह सब है। अब हमें कमांड [F] [/-/]

का उपयोग करके गणना मोड में जाना चाहिए, और फिर हमें प्रोग्राम की शुरुआत में जाने के लिए [/]

की को प्रेस करना होगा। रजिस्टर आरजी 1 में नंबर 5 दर्ज करें ( [5] [X→] [1]

नंबर [5] [X→] [1]

) और निष्पादन शुरू करने के लिए [/]

दबाएं। कैलकुलेटर द्वारा सभी चरणों को पारित करने के बाद, स्क्रीन पर 78.539815 नंबर दिखाई देना चाहिए - 5 के त्रिज्या के साथ सर्कल का क्षेत्र।

बिना शर्त और सशर्त संक्रमण

कमांड []

(51) का उपयोग करते हुए, आप वांछित पते पर बिना शर्त पुनः लोड (गोटो) कर सकते हैं। ऐसा करने के लिए, प्रोग्रामिंग मोड में, आपको []

और फिर उस पते के दो अंकों को दबाया जाना चाहिए, जहां हम जाना चाहते हैं। जब कैलकुलेटर प्रोग्राम निष्पादन के दौरान ऑपरेटर तक पहुंचता है, तो यह निर्दिष्ट पते पर कमांड से निष्पादित करना जारी रखेगा। उदाहरण के लिए:

 ... 10 [F] [-] // 21 11 [] // 51 12 [4] [2] //   (42) ... 42 [+] // 10

इस स्थिति में, चरण 12 के बाद, कैलकुलेटर तुरंत चरण 42 तक आगे बढ़ता है।

सशर्त ब्रांचिंग अधिक उपयोगी है। सशर्त कूद लागू करने के लिए, 4 कमांड हैं: [X >= 0]

, [X < 0]

, [X = 0]

और [X != 0]

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

 ... 09 [F] [*] // 22 10 [F] [←] // "if (X == 0)" (5E) 11 [4] [2] //  ,   ,    42 (42) 12 [+] //  ,  X = 0 (10) ... 42 [4] // 04

चक्र

सशर्त शाखा आदेशों का उपयोग करके लूप्स को लागू किया जा सकता है, लेकिन इसके अलावा, MK-61 में लूप्स के संगठन के लिए, कमांड L0-L3 ( [F] [→X]

, [F] [X→]

, [F] []

[F] []

)। ये कमांड क्रमशः रजिस्टर RG0-RG3 की सामग्री पर काम करते हैं। हर बार लूप कमांड निष्पादित होने पर, 1 को संबंधित रजिस्टर की सामग्री से घटाया जाता है और एक तुलना शून्य के साथ की जाती है। यदि रजिस्टर की सामग्री शून्य के बराबर नहीं है, तो लूप कमांड के बाद रिकॉर्ड किए गए पते पर एक संक्रमण है, यदि बराबर है, तो लूप संक्रमण पते के बाद कमांड में एक संक्रमण है। इसे स्पष्ट करने के लिए, आइए एक उदाहरण देखें। हम रजिस्टर एक्स में स्थित एक संख्या के तथ्यात्मक पर विचार करेंगे।

 //  RG0    ,  RG1 . 00 [X→] [0] //   X  RG0 -    (40) 01 [1] //  1  X (01) 02 [X→] [1] //    RG1 -  (41) 03 [→X] [1] //       (61) 04 [→X] [0] //        (60) 05 [*] //   (12) 06 [X→] [1] //     (41) 07 [F] [→X] // L0 -         .   ... (5) 08 [0] [3] // ...     03... (03) 09 [/] // ... -  (50)

निष्कर्ष

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

कैलकुलेटर प्रोग्रामिंग