तस्वीर ट्यूटोरियल- रजिस्टरों से इंटरप्ट तक

PIC प्रोग्रामिंग के मिनट विवरण में आने से पहले, कुछ अच्छे प्रोग्रामिंग तरीकों को सीखना सबसे पहले महत्वपूर्ण होगा।

रजिस्टरों को समझना

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

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

पाठ्यक्रम में अगली महत्वपूर्ण बात विभिन्न स्थिरांक को नाम निर्दिष्ट करना है (आप उन्हें बाद में विस्तृत रूप से सीखेंगे)। यह एसो को समझने में आसान बनाता है कि इसमें शामिल संख्याओं के साथ भ्रमित होने के बजाय क्या लिखा जा रहा है, या शामिल मूल्यों के बारे में।

तत्काल मान्यता के लिए उपरोक्त को वास्तविक नामों के रूप में किया जाना चाहिए, उदाहरण के लिए COUNT, यह ध्यान रखना महत्वपूर्ण होगा कि यहां सभी बड़े अक्षरों को इसे अलग बनाने के लिए नियोजित किया गया है और यह भी संकेत देता है कि यह एक निरंतर मूल्य है।

जैसा कि हम देख सकते हैं, उपरोक्त अर्धविराम से बने एक बॉक्स के रूप में किया गया है, जिससे यह साफ दिखता है। इसके अतिरिक्त कार्यक्रम को कागज पर भी प्रस्तुत करने का प्रयास करें, इस अभ्यास से चीजों को चरणबद्ध तरीके से समझने में मदद मिलेगी।

2. रजिस्टर।

PIC के भीतर रजिस्टर एक ऐसा क्षेत्र है जो लिखित विवरणों को स्वीकार करता है और साथ ही इसे पढ़ने की अनुमति देता है। आप इसकी तुलना एक कागज़ की शीट से कर सकते हैं जहाँ आप सामग्री की कल्पना कर सकते हैं और उस पर लिखकर जोड़ सकते हैं।

नीचे दिए गए चित्र में PIC16F84 के भीतर एक विशिष्ट रजिस्टर फ़ाइल मैप दर्शाया गया है। प्रारूप कुछ ऐसा नहीं है जो वास्तव में PIC के अंदर सेट किया गया है, यह केवल यह इंगित करने के लिए है कि चिप के अंदर बिट्स को कैसे व्यवस्थित किया जा सकता है और कुछ शामिल कमांडों को समझने के लिए।

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

बैंक 2 केवल जानकारी में हेरफेर करने के लिए है।

इसे निम्नलिखित उदाहरण के माध्यम से समझते हैं:

मान लीजिए कि हम पोर्टा हाई में एक बिट असाइन करना चाहते हैं। इसके लिए हमें पहले आउटपुट के रूप में पोर्ट ए में निर्दिष्ट बिट या पिन सेट करने के लिए बैंक 1 में जाना होगा। इसके बाद हम बैंक 0 पर लौटते हैं और उस विशिष्ट पिन पर एक तर्क 1 (बिट 1) पहुंचाते हैं।

सबसे आम रजिस्टर जो हम बैंक 1 में उपयोग करना चाहते हैं, वे हैं STATUS, TRISA और TRISB।

STATUS हमें बैंक 0 में लौटने में मदद करता है, TRISA हमें यह चुनने की अनुमति देता है कि पोर्ट A पर कौन से पिन आउटपुट हैं और कौन से इनपुट हो सकते हैं, जबकि TRISB, पोर्ट B पर आउटपुट और इनपुट पिन के बीच चयन करने की सुविधा देता है। BANK में SELECT रजिस्टर उपयोगकर्ता को अनुमति देता है बैंक में 1 फ्लिप करने के लिए।

निम्नलिखित विवरण के साथ पूरी अवधारणा को संक्षेप में प्रस्तुत करें:

स्थिति:

बैंक 0 से बैंक 1 में स्विच करने के लिए हम STATUS रजिस्टर को कमांड करते हैं। यह STATUS रजिस्टर के बिट # 5 को 1 पर लागू करके लागू किया गया है। बैंक 0 पर वापस लौटने के लिए, हम STATUS रजिस्टर के बिट 5 को असाइन करते हैं। STATUS रजिस्टर पता 03h पर पोस्ट किया गया है, यहाँ h संख्या tat को दर्शाता है। हेक्साडेसिमल में हो सकता है।

TRISA और TRISB:

ये 85h और 86h पते पर स्थित हैं। एक आउटपुट या इनपुट के रूप में एक पिन की प्रोग्रामिंग के लिए, हम रजिस्टर में एक बिट या एक विशेष बिट तक पहुंचाते हैं। अब यह दो तरीकों से किया जा सकता है, बाइनरी या हेक्स के माध्यम से। मामले में एक पैरामीटर को बदलने में असमर्थ है, वह मानों को लागू करने के लिए वैज्ञानिक कैलकुलेटर के लिए जा सकता है।

अब हमारे पास पोर्ट ए पर 5 पिन हैं, जो 5 पिन से मेल खाती है। यदि हम किसी एक पिन को इनपुट के रूप में ठीक करने का इरादा रखते हैं, तो हम एक '1' विशेष बिट में वितरित करते हैं।

यदि हम किसी एक पिन को आउटपुट के रूप में असाइन करना चाहते हैं, तो हम विशिष्ट पिन को '0' पर सेट करेंगे। बिट्स बिट्स के अनुरूप सटीक नीचे सहायता कर रहे हैं, या अधिक preisey बिट 0 RA0 है, बिट 1 RA1, बिट 2 = RA2 और इसके आगे होगा। इसे इस तरह से समझते हैं:

मान लीजिए कि आप RA0, RA3 और RA4 को आउटपुट के रूप में ठीक करना चाहते हैं, जबकि RA1 / RA2 को i / ps के रूप में, आप 00110 (06h) भेजकर ऐसा करेंगे। यहाँ बताया गया है कि बिट 0 दाईं ओर है।

पोर्ट ए पिन RA4 RA3 RA2 RA1 RA0

बिट संख्या ४ ३ २ १ १ ०

बाइनरी 0 0 1 1 0

वही TRISB के लिए जाता है।

PORTA और PORTB

किसी एक आउटपुट पिन को उच्च करने के लिए, हम अपने PORTA या PORTB रजिस्टर में संबंधित बिट के लिए एक '1' प्रदान करते हैं। TRISA और TRISB रजिस्टरों के लिए भी एक समान प्रक्रिया का पालन किया जा सकता है। इससे पहले कि हम अपने पहले उदाहरण कोडिंग में गति करें, बस अधिक रजिस्टरों के एक कूप को समझें, जैसे: w और f।

डब्ल्यू और एफ

डब्ल्यू रजिस्टर एक साधारण रजिस्टर है जो आपको अपनी पसंद के किसी भी मूल्य को निर्दिष्ट करने में सक्षम बनाता है। जैसे ही आप डब्ल्यू के लिए एक परिमाण असाइन करते हैं, आप इसे दूसरे मूल्य में जोड़कर आगे बढ़ सकते हैं या बस इसे स्थानांतरित कर सकते हैं। किसी अन्य मान के साथ, विवरण केवल डब्ल्यू पर अधिलेखित हो जाते हैं।

एफ एक रजिस्टर पर अपने लिखित मामले को आगे रजिस्टर करता है। हमें इस F रजिस्टर की आवश्यकता होगी एक रजिस्टर पर एक मूल्य प्रदान करने के लिए, STATUS या TRISA रजिस्टर पर हो सकता है, क्योंकि ये हमें सीधे उनके ऊपर मान डालने की अनुमति नहीं देते हैं। एक उदाहरण कार्यक्रम

निम्नलिखित उदाहरण कोड की जांच करें जो हमें दिखाएगा कि उपरोक्त निर्देश कैसे लागू किया गया है और पाठ्यक्रम में कुछ निर्देशों का भी गवाह होगा।

जैसा कि ऊपर चर्चा की गई है, पोर्ट ए को ठीक करने से शुरू करें।

इसके लिए हमें बैंक 0 से बैंक 1 में शिफ्ट होने की आवश्यकता है, यह पता 03h, बिट 5 से 1 के पते पर स्थित STATUS रजिस्टर को सेट करके किया जाता है।

बीएसएफ 03 एच, 5

BSF का मतलब है बिट सेट F. हम इस निर्देश के बाद दो नंबर का उपयोग कर रहे हैं - 03h, जो STATUS रजिस्टर पता है, और नंबर 5 जो बिट नंबर से मेल खाता है।

तो, हम जो कह रहे हैं, वह है 'पता 03h से 1 में बिट 5 सेट करें'।

अब हम बैंक 1 में हैं।

MOVLW 00110 बी

हम अपने सामान्य उद्देश्य रजिस्टर डब्ल्यू में बाइनरी वैल्यू 00110 (अक्षर बी का मतलब है संख्या बाइनरी में है) डाल रहे हैं। मैं निश्चित रूप से हेक्स में ऐसा कर सकता था, जिस स्थिति में हमारा निर्देश होगा:

MOVLW 06 ह

या तो काम करता है। MOVLW का अर्थ है Liter मूव लिटरल वैल्यू इनटू W ’, जिसका अंग्रेजी में अर्थ है कि वह मान जो सीधे W रजिस्टर में आता है।

अब हमें पोर्ट सेट करने के लिए इस मूल्य को अपने TRISA रजिस्टर पर रखना होगा:

MOVWF 85 ह

यह निर्देश इंगित करता है कि 'रजिस्टर के बाद डब्ल्यू पते की सामग्री का अनुसरण करें', इस उदाहरण में पता TRISA को संदर्भित करता है।

इस बिंदु पर हमारा TRISA रजिस्टर 00110 का आंकड़ा रखता है, या रेखांकन प्रस्तुत किया गया है:

पोर्ट ए पिन RA4 RA3 RA2 RA1 RA0

बाइनरी 0 0 1 1 0

इनपुट / आउटपुट O O I I O

इसलिए अब हमारे पास हमारे पोर्ट ए पिन हैं, हमें एक जानकारी को समायोजित करने के लिए बैंक 0 पर वापस लौटना चाहिए।

बीसीएफ 03 एच, 5

यह निर्देश बीएसएफ के रिवर्स को पूरा करता है। इसका मतलब है 'बिट क्लियर एफ'। संख्याओं की एक जोड़ी जो कि पत्राचार रजिस्टर का पता है, यहां STATUS रजिस्टर, साथ ही बिट आंकड़ा भी है, इस उदाहरण में पांच। वर्तमान में हमने जो कुछ भी पूरा किया है, वह हमारे ऊपर बिट फाइव को परिभाषित करता है

स्थिति रजिस्टर ०

हम इस बिंदु पर बैंक 0 में लौटे हैं।
निम्नलिखित एक ब्लॉक में सभी कोड है:

बीएसएफ 03 एच, 5 बैंक 1 पर जाएं
MOVLW 06h W में 00110 डालें
MOVWF 85h चाल 00110 TRISA पर
बीसीएफ 03 ह, 5 बैंक 0 पर वापस आते हैं

अंतिम अनुदेशात्मक के भीतर, हमने आपको संभवतः इनपुट या आउटपुट होने के लिए PIC पर IO पोर्ट पिन स्थापित करने के तरीके की पुष्टि की।

इस कोर्स के माध्यम से, मुझे बंदरगाहों तक डेटा भेजने में आपकी सहायता करने की आवश्यकता है।

पोर्ट्स को डेटा भेजना

बाद के ट्यूटोरियल में, हम एक एलईडी फ्लैश को बंद करके पूरा करने जा रहे हैं जिसमें एक संपूर्ण प्रोग्राम डिटेलिंग और एक सीधा सर्किट आरेख शामिल है ताकि आप PIC को ठीक-ठीक प्रदर्शन करते हुए देख सकें जो हम इसे करने का अनुमान लगा रहे हैं।

केवल नीचे के परिणामों के साथ अपने PIC को एक साथ रखने और प्रोग्राम करने का प्रयास न करें, क्योंकि वे केवल चित्र हैं। प्रारंभ में, हम एक आउटपुट के रूप में पोर्ट ए बिट 2 स्थापित करेंगे:

यह पिछले अनुदेशात्मक से पहचानने योग्य हो सकता है। एकमात्र अंतर यह हो सकता है कि हम उत्पादन के रूप में A पर पिन के हर बिट को तय कर सकते हैं, 0h को त्रि-राज्य रजिस्टर में वितरित करके। तो अब उसे क्या करना चाहिए एक एलईडी चालू है।

हम इसे पिंस में से एक (एलईडी से जुड़ा हुआ) उच्च शेड्यूल करके पूरा करते हैं। इसे अलग तरीके से रखने के लिए, हम पिन पर it 1 ’लगाते हैं। यह ठीक उसी तरह है जैसे यह किया गया है (हर पंक्ति के स्पष्टीकरण के लिए टिप्पणियों का अवलोकन करें):

इसलिए, अब जो हमने पूरा किया है वह एलईडी को एक बार बंद कर देता है। हम जो चाहते हैं वह एलईडी के लिए बाद में लगातार बंद करने के लिए है।

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

हम एक शब्द में कुंजी कहते हैं, START, अगला कोड लिखें:

जैसा कि प्रदर्शित किया गया है, हमने शुरू में कार्यक्रम की शुरुआत में तुरंत 'प्रारंभ' का उल्लेख किया।

इसके बाद, कार्यक्रम के अंत में हमने स्पष्ट रूप से 'गोटो स्टार्ट' का उल्लेख किया। Declar गोटो ’निर्देश केवल वही घोषित करता है जो वह घोषित करता है।

जब भी हम बिजली निकालते हैं, तो यह प्रोग्राम लगातार एलईडी को स्विच ऑफ करेगा और जब भी हम सर्किट को बंद करेंगे, स्विच ऑफ हो जाएगा। हो सकता है कि हमें अपना कार्यक्रम फिर से जाँचना चाहिए:

निश्चित रूप से हमने टिप्पणियों को छोड़ दिया है, हालांकि हम अभी भी निर्देशों और संख्याओं का निरीक्षण कर सकते हैं।

यदि आप प्रोग्राम को समस्याग्रस्त करने की कोशिश कर रहे हैं और कोड लिखते समय आप पतों के बारे में याद कर रहे हैं तो यह थोड़ा हैरान करने वाला हो सकता है।

हालांकि टिप्पणियों को रखा जा सकता है फिर भी यह थोड़ा अव्यवस्थित हो सकता है। इसके लिए संख्याओं के नामकरण की आवश्यकता होगी और एक अतिरिक्त निर्देश द्वारा पूरा किया जा सकता है: 'बराबर' 'बराबर' निर्देश बताता है कि कुछ सामान दूसरे सामान के बराबर हो सकता है।

यह PIC के लिए एक निर्देश नहीं हो सकता है, बल्कि कोडांतरक के लिए। यह निर्देश एक रजिस्टर पते के स्थान, या एक प्रोग्रामिंग शब्द के लिए एक नाम निर्दिष्ट करने की सुविधा प्रदान करता है।

हम अपने कार्यक्रम के लिए कुछ स्थिरांक स्थापित करेंगे और यह भी देखेंगे कि यह कार्यक्रम कितना सरल है।

चूंकि अब हमने निरंतर मानों को तय कर लिया है जिन्हें हम अपने कार्यक्रम में स्थापित करके आगे बढ़ सकते हैं। उपयोग करने से पहले स्थिर मूल्यों को निर्दिष्ट करने की आवश्यकता है।

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

हो सकता है कि आप यह नोटिस कर सकें कि स्थिरांक कार्यक्रम की थोड़ी आसान समझ को सक्षम कर रहे हैं, हालांकि हम अभी भी टिप्पणियों के बिना हैं, हालांकि कोई चिंता नहीं है, क्योंकि हम अभी तक समाप्त नहीं हुए हैं।

हमारे चमकती एलईडी कार्यक्रम के एक छोटे से नकारात्मक पहलू हो सकता है।
हर निर्देश को समाप्त करने के लिए 1 घड़ी अनुक्रम की आवश्यकता होती है। यदि हम 4MHz क्रिस्टल का उपयोग कर रहे हैं, तो हर निर्देश 1 / 4MHz, या 1uS को समाप्त करने के लिए कहता है।

जब से हम सिर्फ पाँच निर्देशों को नियोजित कर रहे हैं, तब एलईडी 5uS में सक्रिय हो जाएगा। यह नोटिस करने के लिए लोगों के लिए बहुत तेजी से हो सकता है, इसके अलावा, ऐसा लगेगा कि एलईडी पूरी तरह से चालू है।

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

शून्य मान देरी के निष्कर्ष को दर्शाता है, और हम पूरे कार्यक्रम में अपनी प्रक्रिया को काम करते रहते हैं। इसलिए, सबसे पहले हमें अपने काउंटर के उपयोग के लिए एक निरंतरता निर्धारित करना होगा।

चलिए हम इस निरंतर COUNT को समाप्त करते हैं। उसके बाद, हमें यह निर्धारित करना होगा कि गिनती शुरू करने के लिए कितनी महत्वपूर्ण संख्या है। निश्चित रूप से, हम जो सबसे बड़ा आंकड़ा शामिल कर सकते हैं वह है 255, या FFh हेक्स में। जैसा कि मैंने पहले ट्यूटोरियल में बात की थी, समान निर्देश एक रजिस्टर स्थिति को एक अभिव्यक्ति प्रदान करता है।

इसका तात्पर्य यह है कि हम अपने COUNT को चाहे कितनी भी मात्रा में आवंटित करें, यह एक रजिस्टर के आइटम से मेल खाएगा। यदि हम FFh का मान निर्दिष्ट करने का प्रयास करते हैं, तो हमें एक बार प्रोग्राम को संकलित करने के लिए गलती होने वाली है।

FFh का स्थान होने का कारण है, इसलिए हम इस तक पहुंच प्राप्त नहीं कर सकते हैं। इसलिए, हमें वास्तविक संख्या कैसे निर्दिष्ट करनी चाहिए? निश्चित रूप से, इसे थोड़ी मात्रा में लेटरल पॉन्ड्रिंग की आवश्यकता होगी।

उदाहरण के लिए, यदि हम अपने COUNT को 08h पते पर निर्दिष्ट करते हैं, तो यह मूल उद्देश्य रजिस्टर गंतव्य को इंगित करेगा। डिफ़ॉल्ट रूप से, अछूते क्षेत्रों को FFh पर सेट किया जाता है। नतीजतन, अगर COUNT 08h की ओर जाता है, तो आप FFh के मूल्य का सामना करेंगे, जब हम पहली बार पावर अप करेंगे। फिर भी, मैं आपको बताता हूं कि हम किसी अन्य संख्या के लिए COUNT को कैसे ठीक कर सकते हैं ?, हम जो भी लागू करते हैं, वह इस गंतव्य के लिए एक मूल्यांकन है।

एक दृष्टांत के रूप में, मान लें कि हमने COUNT की कीमत 85h के मान पर रखी है, हम COUNT का उल्लेख 85h नहीं कर सकते हैं क्योंकि यह पोर्ट ए के लिए त्रि-राज्य रजिस्टर की स्थिति है। सटीक रूप से हम जो पूरा करते हैं वह निम्नलिखित है: Movl 85hFirst put डब्ल्यू रजिस्टर movwf 08h में 85 h का मान

अब इसे हमारे 08h रजिस्टर पर ले जाएँ। इसके बाद, अगर हम COUNT समान 08h व्यक्त करते हैं, तो COUNT मूल्य 85h से मेल खाएगा। नाजुक, यह नहीं है! इसलिए, शुरू में हम अपने निरंतर का निर्धारण करते हैं: COUNT बराबर 08h का पालन करते हुए हमें इस COUNT को शून्य तक कम करना चाहिए।

यह बस इतना होता है कि o गोटो ’और एक टैग का उपयोग करके हमारे लिए इसे पूरा करने के लिए डिज़ाइन किया गया एक निर्देश मौजूद है।

हम जो निर्देश लागू करने जा रहे हैं, वह है: DECFSZ COUNT, 1 यह निर्देश बताता है कि अल्पविराम को ट्रैक करने वाली संख्या से रजिस्टर (यहाँ यह COUNT है) को घटाएँ। यदि हम शून्य प्राप्त करते हैं, तो दो स्थानों से आगे बढ़ने की आशा करते हैं। '

हमने जो प्रदर्शन किया है वह शुरू में हमारे निरंतर COUNT को 255 पर स्थापित करता है। बाद वाला खंड एक टैग को पोस्ट करता है, जिसे LABEL कहा जाता है जो हमारे डिकैफ़् स अनुदेश के पास है।

डिकैफ़्ज़ COUNT, 1 COUNT का मान एक घटाता है, और अंतिम परिणाम को सीधे COUNT में रखता है। इसके अलावा यह जाँचने के लिए सत्यापित करता है कि COUNT 0 के मान के पास है या नहीं।

यदि यह नहीं होता है, तो यह उस स्थिति में प्रोग्राम को बाद की लाइन में शिफ्ट करने के लिए ट्रिगर करता है। अब हमारे पास एक o गोटो ’घोषणा है जो हमें हमारे डीएफ़एसज़ अनुदेश पर वापस भेजती है।

यदि COUNT का मान समान है, तो हमारे प्रोग्राम में डीएफ़एसज़ अनुदेश परिणाम 2 स्पॉट आगे छलांग लगाने के लिए है, और हमें उस स्थान पर भेजा जाता है जहां हमने 'कैरी ऑन' का दावा किया है। '

इसलिए, चूंकि आप निरीक्षण कर सकते हैं, हम आगे बढ़ने से पहले पूर्व निर्धारित समय के लिए एक स्थान पर बैठने के कार्यक्रम के बारे में लाए हैं। इसे विलंब लूप नाम दिया जा सकता है।

देरी लूप्स को समझना

मामले में हमें और अधिक पर्याप्त देरी की आवश्यकता है, हम अगले द्वारा एक लूप का पीछा कर सकते हैं। अतिरिक्त छोरों, देरी को बढ़ाया। हमें कम से कम दो, यह मानते हुए कि हम एलईडी फ्लैश का निरीक्षण करना चाहते हैं .. हम इन विलंब छोरों को अपने कार्यक्रम में जगह देंगे, और टिप्पणियों को प्रस्तुत करके इसे एक वास्तविक कार्यक्रम प्रदान करके पूरा करेंगे:

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

ठीक है, आप वास्तव में अपने पहले PIC कार्यक्रम की रचना कर सकते हैं, साथ ही एक एलईडी को बंद और पलक झपकाने के लिए एक सर्किट का निर्माण कर सकते हैं। अब तक, यदि आपने इन पाठ्यक्रमों को लागू कर दिया है, तो आप 35 में से कुल सात निर्देश सीख सकते हैं, लेकिन संदेह के बिना अब तक आप I / O पोर्ट को नियंत्रित कर सकते हैं!

क्या आप एलईडी फ्लैश को तेज करने के लिए विलंब छोरों को बदलने का प्रयास करेंगे - एलईडी फ्लैश को अनिवार्य रूप से देखने के लिए COUNT का न्यूनतम मूल्य क्या प्रतीत होता है? या हो सकता है, आप एलईडी को स्थिर करने के लिए प्रारंभिक एक के बाद एक 3 या पूरक विलंब छोरों को शामिल करना चाहेंगे। प्रत्येक विलंब लूप के लिए एक अद्वितीय स्थिरांक।

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

Subroutines क्या हैं

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

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

हमारे कार्यक्रम में कहीं से भी सबरूटीन शुरू करने के लिए, हम जल्दी से निर्देश CALL टाइप करते हैं और फिर सबरूटीन पदनाम।

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

जब भी निर्देश RETURN पूरा हो जाता है, तो कार्यक्रम हमारे प्रिंसिपल प्रोग्राम पर वापस आ जाता है, जो हमारे CALL xxx निर्देश के बाद अनुदेश में आता है।

इसी तरह के सबरूटीन को कई बार कॉल करना संभव है जैसा कि आप चाहेंगे, जो बताता है कि सबरूटीन्स का उपयोग हमारे कार्यक्रम की सामान्य अवधि को कम क्यों करता है।

फिर भी, कुछ ऐसे कारक हैं जिनके बारे में आपको पता होना चाहिए। प्रारंभ में, हमारे प्रमुख कार्यक्रम की तरह, किसी भी विशिष्ट स्थिरांक को स्वीकार करने से पहले आपको उनका उपयोग करने की आवश्यकता होती है।

संभवतया ये सबरूटीन के भीतर या सीधे प्रिंसिपल प्रोग्राम की शुरुआत में स्वीकार किए जा सकते हैं। मैं आपको प्रस्तावित करता हूं कि आप अपने मुख्य कार्यक्रम की शुरुआत में सब कुछ स्वीकार करते हैं, तब से आप पहचानते हैं कि चीजें एक समान स्थिति में हैं। अगला, किसी को यह सुनिश्चित करना चाहिए कि मुख्य कार्यक्रम उप-रेखा के ऊपर से निकल जाता है।

इसके साथ मैं जो कुछ भी करता हूं, उसे आपको अपने प्राथमिक कार्यक्रम के समापन पर सीधे उप-स्थल पर रखना चाहिए, सिवाय इसके कि अगर आप सब-आउट कहां हैं, तो इस कार्यक्रम को जारी रखने और लागू करने के लिए 'गोटो' की घोषणा का उपयोग करें, भले ही आप इसकी परवाह किए बिना सब-साइट पर लागू हों। यह अन्यथा करने की आवश्यकता है।

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

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

हर बार जब हम देरी की इच्छा करते हैं, संभवतः जब एलईडी चालू या बंद होता है, तो हम मूल रूप से देरी को उप-कॉल कहते हैं। सबरूटीन के समापन पर, कार्यक्रम हमारे instruction कॉल ’निर्देश का पालन करते हुए लाइन में वापस आ जाता है। ऊपर चित्रण में, हम एलईडी को फ्लिप करते हैं।

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

सबरूटीन के उपयोग के माध्यम से, हम अपने कार्यक्रम का आकार 103 बाइट्स तक कम कर सकते हैं। यह इतना शानदार नहीं लग सकता था, हालांकि इस तथ्य पर विचार करते हुए कि हमारे पास PIC के अंदर कुल 1024 बाइट्स हैं, प्रत्येक छोटी राशि का लाभ होता है।

अगले अनुदेशात्मक के भीतर, हम बंदरगाहों से पढ़ने की जाँच करते हैं।

अब तक, हम पोर्ट ए की रचना कर रहे हैं ताकि हम एक एलईडी को चालू और बंद कर सकें। इस बिंदु पर, हम देखेंगे कि हम बंदरगाहों पर I / O पिन कैसे पढ़ने जा रहे हैं।

इनपुट / आउटपुट पोर्ट पढ़ना

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

क्या आपको हमारे पहले के पाठ्यक्रमों से याद रखना चाहिए, यदि आप I / O पोर्ट स्थापित करना चाहते हैं, तो हमें Bank 0 से Bank 1. में कूदने की आवश्यकता है। हम शुरू में इसे पूरा करेंगे:

इस बिंदु पर हमने इनपुट के लिए पोर्ट ए के बिट 0 को निर्धारित किया है। हमें अब जांचना चाहिए कि क्या पिन उच्च या निम्न है। इसे पूरा करने के लिए, व्यक्ति केवल दो निर्देशों में से एक का उपयोग कर सकता है:

BTFSC और BTFSS।

बीटीएफएससी निर्देश। रजिस्टर पर एक सा परीक्षण करते हैं और साथ ही साथ हम नामित करते हैं।

यदि यह 0 है, तो उस स्थिति में हम बाद के निर्देश को छोड़ देते हैं '। BTFSS का तात्पर्य है and रजिस्टर और बिट में हम परीक्षण करते हैं। मामले में यह 1 पर सेट है, तो हम बाद के निर्देश को बायपास करते हैं।

हम जिसका उपयोग करते हैं, वह ठीक उसी तरह से निर्धारित होता है, जब हम इनपुट का अध्ययन करते हुए प्रतिक्रिया देने के लिए अपने कार्यक्रम की इच्छा करते हैं। एक दृष्टांत के रूप में, यदि हम केवल 1 होने के लिए इनपुट का इंतजार कर रहे हैं, तो हम निम्नलिखित तरीके से BTFSS निर्देश का उपयोग करने में सक्षम हो सकते हैं:

यहाँ कोड:

बीटीएफएसएस पोर्टा, 0 गोटो की शुरुआत यहां से करें:
:

कार्यक्रम सिर्फ 'कैरी ऑन' पर शिफ्ट होगा 'बशर्ते कि पोर्टा पर बिट 0 एक 1 के लिए निर्धारित हो।

हम वर्तमान में एक कार्यक्रम लिखेंगे जो एक दर पर एलईडी का संकेत दे सकता है, हालांकि अगर एक स्विच सीमित है तो यह एलईडी को दो बार धीमा कर देगा।

यह संभव है कि इस कार्यक्रम को अपने दम पर अभ्यास करें, फिर भी हमने किसी भी तरह सूची को शामिल किया है।

यदि आप सिद्धांतों को समझ गए हैं, तो यह जांचने के लिए आप पूरे कार्यक्रम का प्रयास और लेखक कर सकते हैं। हम पहले की तरह बराबर सर्किट का उपयोग कर रहे होंगे, जिसमें PIC के एक स्विच संलग्न RA0 और हमारी आपूर्ति की सकारात्मक रेल शामिल होगी।

हमने यहां जो पूरा किया है वह एलईडी को चालू करना है। मैं बाद में निर्धारित करता हूं कि स्विच बंद है या नहीं।

मामले में यह सीमित है, अगले मैं हमारी देरी उप-प्रक्रिया से जोड़ता हूं। यह हमें पहले की तरह समान देरी प्रदान करता है, हालाँकि हम इस बिंदु पर दो बार संपर्क कर रहे हैं।

जब भी एलईडी बंद हो, यही बात लागू होती है। यदि स्विच बंद नहीं होता है, तो हमारे पास पिछले और बंद अवधियों में दर्ज की गई हमारी प्रजाति है।

क्या आप शुरू से ही इन पाठों का पालन कर रहे हैं, आप समझ सकते हैं कि आपने वर्तमान में PICF84 के लिए 35 निर्देशों में से दस को खोज लिया है! और इनमें से हर एक को केवल एक एलईडी चालू और बंद करके सीखा जाना चाहिए।

अब तक, हमने पीआईसी ब्लिंक को एक एलईडी और बंद पर बनाया है।

बाद में हम एक स्विच को शामिल करके हमारे PIC के साथ सक्षम थे, इसलिए फ्लैश की गति अलग-अलग थी।

मेमोरी स्पेस का कुशल रूप से उपयोग करना

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

Movlw 02hmovwf PORTAmovlw 00hmovlw PORTA

सबसे पहले हमने अपने w रजिस्टर को 02h के साथ भरा, उसके बाद इसे LED को स्विच करने के लिए हमारे PortA रजिस्टर में ट्रांसफर कर दिया। इसे बंद करने के लिए, हमने 00h के साथ w पैक किया जिसके बाद इसे हमारे पोर्टा रजिस्टर में स्थानांतरित कर दिया गया।

इन सभी दिनचर्या के बीच हमें यह सुनिश्चित करने के लिए एक उप-मार्ग के संपर्क में आने के लिए मजबूर किया गया था कि हम एलईडी फ्लैशिंग का निरीक्षण कर सकें।

इसलिए, हमें जानकारी के दो सेटों को दो बार (डब्ल्यू रजिस्टर में एक बार तब पोर्तो में) स्थानांतरित करने की आवश्यकता थी और साथ ही दो बार एक सबरूटीन (एक बार बंद होने पर एक बार) कॉल करने की आवश्यकता थी। इस प्रकार, हम इसे अतिरिक्त दक्षता के साथ कैसे प्राप्त कर सकते हैं? बहुत आसान।

हम XORF नामक एक अलग निर्देश का उपयोग करते हैं। XORF इंस्ट्रक्शन रजिस्टर पर एक एक्सक्लूसिव या फंक्शन का काम करता है जिसे हम प्रदान की गई जानकारी के साथ निर्धारित करते हैं। मेरा मानना ​​है कि मुझे यह स्पष्ट करना होगा कि दुनिया में क्या एक विशेष या इससे पहले कि हम जारी रखें। मामले में हमारे पास दो इनपुट हैं, और एक आउटपुट है, इनपुट केवल 1 हो सकता है, और जब तक, दोनों इनपुट अलग-अलग हों। जबकि वे समान हैं, तो आउटपुट शायद 0. होगा। निम्नलिखित एक सत्य तालिका है, उन व्यक्तियों के लिए जो इनकी जांच करना चुनते हैं:

A B F0 0 00 1 11 0 11 1 0

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

अ ब फ
० ० ०
० ० ०
१ ० १
१ १ ०
१ ० १

यदि हम A का मान 1 रखते हैं, और हम विशेष या इसे आउटपुट के साथ रखते हैं, तो आउटपुट टॉगल होगा। यदि आप इसे सत्य तालिका से नोटिस नहीं कर सकते हैं, तो नीचे बाइनरी का उपयोग देखा जा सकता है:

0 वर्तमान उत्पादन
EX-OR 1 1 नए आउटपुट के साथ
EX-OR 1 0 नए आउटपुट के साथ

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

MOVLW 02 ह
XORWF DOOR, 1

जो हम पूरा कर रहे हैं वह ठीक है कि हम 02h के साथ अपना w रजिस्टर जोड़ रहे हैं। हम इस मामले में हैं कि हमारे पोर्टा पर कोई फर्क नहीं पड़ता है। यदि मामला 1 में 1 है, तो यह 0. में बदलने जा रहा है। यदि केस 1 में 0 है, तो यह 1. में बदलने जा रहा है। इस कोड को एक या दो बार, यह दिखाने के लिए कि यह द्विआधारी कैसे चल रहा है, इसकी जांच करें।

दरवाजा
00010 है
xorwf 00000
xorwf 00010
xorwf 00000
xorwf 00010

हमें वास्तव में हर बार हमारे डब्ल्यू रजिस्टर में समान मूल्य को लोड नहीं करना पड़ता है, इसलिए शुरुआत में यह एक बार पूरा करना संभव है, और बस हमारे टॉगल कमांड पर वापस छलांग लगाना है। इसके अतिरिक्त, हमें अपने पोर्टा रजिस्टर पर एक मूल्य तय करने की जरूरत नहीं है। कारण? निश्चित रूप से, चूंकि पावर अप के मामले में यह 1 है, हम आसानी से इसे टॉगल कर सकते हैं। मैं, वैकल्पिक रूप से 0 अप पावर पर, हम अब भी इसे टॉगल करेंगे।

इसलिए आप हमारे नवगठित कोड को देखना चाहेंगे। पहला हमारे निमिष एलईडी कोड का प्रतिनिधित्व करता है, जबकि दूसरा स्विच के अतिरिक्त दिखाता है:

काश आप पा सकते हैं कि बस एक आसान निर्देश का उपयोग करके, हमने अब हमारे कार्यक्रम के पैमाने को काट दिया है। सच्चाई यह है कि, हम अपने कार्यक्रमों को कितना कम कर सकते हैं, यह प्रदर्शित करने के लिए, हमने दो कार्यक्रमों का प्रदर्शन किया है, बस जो रचना की गई थी, और उनके आयाम नीचे दिए गए हैं:

कार्यक्रम में परिवर्तन (बाइट्स)
चमकती एलईडी मूल 120
चमकती एलईडी सबरूटीन 103 जोड़ा गया
चमकती एलईडी XOR फंक्शन 91 इस्तेमाल किया
स्विच ऑरिजनल 132 के साथ एलईडी
स्विच XOR फ़ंक्शन के साथ एलईडी का उपयोग 124।

इसलिए, न केवल हमने कुछ उपन्यास निर्देशों की खोज की है, हम निश्चित रूप से इसके अलावा हमारे स्क्रिप्टिंग के आकार में कमी आई है!

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

तार्किक प्रबंधक

अंतिम ट्यूटोरियल के भीतर मैंने एक्सक्लूसिव या ऑपरेशन प्रस्तुत किया। एक्सओआर फ़ंक्शन को तार्किक ऑपरेटर के रूप में समझा जाता है।

इस ट्यूटोरियल में मैं उन अतिरिक्त तार्किक ऑपरेटरों को बताऊंगा जो PIC को बढ़ावा देते हैं। बिंदु कार्यक्रमों में किसी भी तरह का मामला नहीं होगा, हालांकि हम कोड के छोटे क्षेत्रों को लागू करके ऑपरेटरों का उपयोग करने के लिए आसान तरीके सीखेंगे।

और AND फ़ंक्शन मूल रूप से दो बिट्स का विश्लेषण करता है और एक 1 बचाता है कि क्या वे समान हैं, और 0 एक मामले में वे विशिष्ट हैं। उदाहरण के लिए, यदि हमने 1 और 1 का उल्लेख किया है, तो परिणाम 1 है, जबकि मामले में हमने 1 और 0 घोषित किया था, परिणाम 0 होगा।

कहने की जरूरत नहीं है, हम शब्दों का भी मूल्यांकन करने में सक्षम हैं, साथ ही सभी एंड फ़ंक्शन उपलब्धियां दो शब्दों को थोड़ा-थोड़ा करके समीक्षा करती हैं। नीचे दिया गया उदाहरण उत्पाद के साथ एक साथ दो 8-बिट शब्दों को प्रदर्शित करता है:

11001011
और 10110011
बराबर 10000011

मुझे आशा है कि आप सहमत होंगे, परिणाम बस एक 1 के पास होगा जब 2 2 एस हाथ में एक दूसरे के साथ शब्दों की एक जोड़ी में हाथ। हम उदाहरण के लिए बंदरगाहों को सत्यापित करने के लिए AND फ़ंक्शन का उपयोग करने में सक्षम हैं।

मामले में हम कुछ I / O पिंस की जाँच कर रहे हैं जो एक सर्किट से जुड़े हुए हैं, और हमें एक विशेष स्थिति पर नज़र रखनी चाहिए जिसमें केवल कुछ पिन अधिक हैं, उस स्थिति में हम बहुत अधिक पढ़ने में सक्षम हैं पोर्ट, जिसके बाद और उस स्थिति के साथ परिणाम जिसके लिए हम जांच कर रहे हैं, उपरोक्त उदाहरण के समान है।

PIC हमें AND के लिए दो सामग्री प्रदान करता है।
वे ANDLW और ANDWF हैं। ANDLW हमें W रजिस्टर के विवरण के साथ AND फ़ंक्शन करने की अनुमति देता है, और एक राशि जिसे हम निर्धारित करते हैं।

वाक्य रचना है: ANDLW जिसमें वास्तव में हम क्या करने जा रहे हैं और डब्ल्यू की सामग्री के साथ।

AND फ़ंक्शन का परिणाम सीधे W रजिस्टर में संग्रहीत किया जाएगा।
ANDWF हमें W रजिस्टर और एक अलग रजिस्टर पर AND फ़ंक्शन करने की अनुमति देता है, उदाहरण के लिए PORT। वाक्यविन्यास है: ANDWF, d जिसमें वह रजिस्टर है जिसके बारे में हम उत्साही हैं, उदा। PORTA, और d उस PIC को दिखाता है जहाँ आपको परिणाम की स्थिति निर्धारित करनी चाहिए। यदि d = 0, परिणाम W रजिस्टर में रखा जाता है, और d = 1 अंतिम परिणाम उस रजिस्टर में सहेजा जाता है जिसे हमने निर्धारित किया था। नीचे दिए गए कोड के दो भाग प्रत्येक और फ़ंक्शन का एक अच्छा उदाहरण प्रदर्शित करते हैं।

प्रारंभिक PORTA की स्थिति की जांच कर रहा है, जिसमें हमें जांचने की ज़रूरत है कि क्या इनपुट 1100 हैं। हम परिणाम को डब्ल्यू रजिस्टर में वापस रख सकते हैं।

Movlw 1100
ANDWF 05h, 0 दूसरा चित्रण अब W रजिस्टर की सामग्री को सत्यापित कर सकता है:
ANDLW 1100

या

हमने अब तक एक या फंक्शन की खोज की है, एक्सओआर के सटीक होने के लिए। यह एक 1 में विकसित होता है अगर दो बिट समान नहीं होते हैं, लेकिन अलग-अलग होते हैं। आप IOR नामक एक और OR फ़ंक्शन पा सकते हैं, जो समावेशी OR है। यह फ़ंक्शन 1 उत्पन्न करेगा यदि कोई बिट 1 या तो है, लेकिन इसके अतिरिक्त यदि प्रत्येक बिट्स 1 हैं। नीचे यह स्पष्ट करने के लिए एक स्पष्ट कट टेबल है:

A B O / P
० ० ०
0 1 1
१ ० १
१ १ १

अंकगणित संचालक क्या हैं

जोड़ें

यह फ़ंक्शन यह दावा करता है कि आमतौर पर यह क्या दावा करता है। इसमें दो आकृतियों का योगदान है! यदि दो आंकड़ों को जोड़ने का परिणाम 8 बिट्स से अधिक हो जाता है, तो उस स्थिति में एक काररी झंडा शायद सेट किया जाएगा। कैर्री ध्वज पता 03h बिट 0 पर स्थित है।

जब यह बिट निर्धारित होता है, तो दो आंकड़े 8 बिट्स से आगे निकल जाते हैं। जब यह 0 होता है, उस स्थिति में परिणाम 8 बिट्स के भीतर स्थित होता है। पहले की तरह, PIC हमें ADDLW और ADDWF के ADD की दो शैलियाँ वितरित करता है। जैसा कि आपने माना होगा, यह उपरोक्त फ़ंक्शन की तरह है। ADDLW डब्ल्यू रजिस्टर की सामग्री प्रदान करता है जिसे हम निर्धारित करते हैं। वाक्यविन्यास है: ADDLW ADDWF डब्ल्यू रजिस्टर की सामग्री और कुछ अन्य रजिस्टर जो हम नामित करते हैं, जोड़ते हैं।

वाक्य रचना है: ADDWF, d जहां है

विषय

इस बिंदु पर, मुझे लगता है कि आप यह नहीं मान सकते हैं कि यह फ़ंक्शन क्या करता है! वास्तव में, आपको यह संदेह था, यह कार्य
एक बिट को दूसरे से घटाता है। फिर से PIC हमें 2 स्वाद प्रदान करता है: SUBLW और SUBWF। वाक्यविन्यास ठीक ADD फ़ंक्शन के लिए समान है, इसके अलावा आप ADD के स्थान पर SUB टाइप करते हैं!

वृद्धि मामले में हम PIC में एक नंबर को शामिल करना चाहते हैं, हम पूरी तरह से ADD फ़ंक्शन का उपयोग कर सकते हैं, और नंबर एक का उपयोग कर सकते हैं। ~ इसके साथ कठिनाई यह है कि हमें पहले डब्ल्यू रजिस्टर में आंकड़ा डालना चाहिए, बाद में इसे बढ़ाने के लिए ADDLW 1 नियंत्रण का उपयोग करना चाहिए। यदि हम एक रजिस्टर में 1 को शामिल करना चाहते हैं, तो यह अभी भी खराब हो सकता है। हमें पहले नंबर को W रजिस्टर में रखना होगा, उसके बाद ADDWF, 1 का उपयोग करना चाहिए। इसलिए, उदाहरण के लिए, 1 से 0C को शामिल करने के लिए, हमें स्क्रिप्ट के निम्नलिखित भाग के अधिकारी होने की आवश्यकता होगी:

मोलवव ०१
addwf 0 सी, 1

इस के संचालन की एक आसान विधि मौजूद है। हम कमांड INCF का प्रयोग कर सकते हैं। वाक्यविन्यास है: INCF, d जहाँ, रजिस्टर, या स्थान है, जिसे हम संबंधित हैं और d उस PIC को दर्शाता है जहाँ आपको परिणाम की स्थिति निर्धारित करनी चाहिए। यदि मामले में d = 0 है, तो परिणाम W रजिस्टर में है, और मामले में d = 1 में, परिणाम उस रजिस्टर में सेट किया गया है जिसे हमने निर्धारित किया है।

इस व्यक्तिगत निर्देश का उपयोग करके हम वास्तव में पचास प्रतिशत कोडिंग करने में सक्षम हैं। यदि हम वांछित परिणाम को W रजिस्टर में बहाल करना चाहते हैं, तो उस स्थिति में ऊपर दिए गए उदाहरण को नियोजित करने के लिए, हमें 0C की वस्तुओं को वापस डब्ल्यू रजिस्टर में शिफ्ट करने के लिए एक अतिरिक्त कमांड को शामिल करना पड़ सकता है, जिसके बाद 0C रजिस्टर को वापस नहीं यह क्या था।

वहाँ वेतन वृद्धि आदेश मौजूद है। यह INCFSZ है। यह कमांड उस रजिस्टर को बढ़ा सकती है जिसे हम निर्धारित करते हैं, हालांकि अगर हम रजिस्टर बढ़ाते हुए 0 के बराबर हो जाता है (जो तब होगा जब हम 1 से 127 में शामिल होते हैं) उसके बाद पीआईसी शायद बाद के निर्देश को पारित करेगा। नीचे दिए गए कोड का भाग यह दर्शाता है:

लूप incfsz 0C
गोटो लूप
:
:
कार्यक्रम के अवशेष।

कोड के ऊपर के हिस्से में, 0 सी को बढ़ाकर 1 किया जा रहा है। हमारे पास एक निर्देश है जो PIC को लूप नाम के हमारे टैग पर वापस लौटने के लिए सूचित करता है, और 0C को 1 फिर से बढ़ाता है। यह तब तक जारी रहता है जब तक 0C 127 के बराबर नहीं हो जाता है। इस परिस्थिति में, जब हम 0C को 1 से बढ़ाते हैं, 0C अब मिलान करने जा रहा है। हमारी INCFSZ निर्देश बहुत अच्छी तरह से PIC को बाद के निर्देश को छोड़ने के लिए सूचित कर सकता है, जो इस उदाहरण में मिली घोषणा है, इसलिए PIC शेष कार्यक्रम के साथ आगे बढ़ेगा।

घटती

हमने अब पहले के प्रशिक्षण में वेतन वृद्धि समारोह पर चर्चा की है, इसलिए मैंने इसे अब संशोधित नहीं किया है।

पूरक हैं

इस चर्चा में अंतिम निर्देश उस रजिस्टर में हर एक बिट को उलट देगा जिसे हम निर्धारित करते हैं। वाक्य रचना है: COMF, d जिसमें

बिट संचालन को समझना

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

इस पाठ्यक्रम के समापन पर हम एक कार्यक्रम का खुलासा करेंगे जो कि आगे बढ़ने वाले अनुक्रमण रोशनी का एक सेट बनाने के लिए डिज़ाइन किया गया है, फिर रिवर्स तरीका। जब हमने एक्सक्लूसिव OR फंक्शन की जांच की, तो हमने इसे पहले पूरा किया। जब हमने PIC पर पोर्ट स्थापित किया है, तब हमने कुछ कार्य किए हैं

मुझे उनके उपयोग को यहाँ दोहराना है।

बीसीएफ

यह निर्देश थोड़ा सा मिटा देगा कि हम एक रजिस्टर में निर्धारित करते हैं जिसे हम नामित करते हैं। वाक्य रचना
है:
बीसीएफ,

हमने पहले इसे STATUS रजिस्टर में थोड़ा हटाकर पेज 1 से पेज 0 में बदलने के लिए नियोजित किया था। हम इसी तरह किसी भी अलग रजिस्टर / स्थान पर 0 से थोड़ा ठीक करने के लिए इसका उपयोग करने में सक्षम हैं। उदाहरण के लिए, यदि हम चाहते हैं कि 11001101 में तीसरी बिट को 0C से 0 सेक्शन में बचाया जाए, तो हम कर सकते हैं
सम्मिलित करें:

बीसीएफ 0 सी, 03

बीएसएफ

यह निर्देश किसी भी रजिस्टर में किसी भी बिट को निर्धारित करेगा जिसे हम इंगित करते हैं। हमने इसका उपयोग पहले पृष्ठ 0 से पृष्ठ 1 पर आगे बढ़ने के लिए किया। वाक्यविन्यास है: BSF ,, और ऊपर BCF के रूप में ठीक उसी तरीके से उपयोग किया जाता है।

BTFSCUp अब हम रजिस्टर में थोड़ा सेट या क्लियर कर सकते हैं। हालांकि कल्पना कीजिए कि अगर हमें मूल रूप से जांचने की ज़रूरत है कि क्या एक बिट एक रजिस्टर में 1 या 0 है?

निश्चित रूप से, बीटीएफएससी का उपयोग करना संभव है। यह बताता है कि बिट टेस्ट रजिस्टर एफ, और स्किप इफ इज़ क्लियर है। यह निर्देश रजिस्टर में नामित बिट का विश्लेषण करने वाला है। यदि मामला थोड़ा है, तो निर्देश बाद में निर्देश पारित करके PIC को सूचित करेगा।

हम इस निर्देश का उपयोग उस स्थिति में कर सकते हैं जब हम एक ध्वज की जाँच करना चाहते हैं, उदाहरण के लिए ध्वज ले जाना। इससे हमें यह जानने की जरूरत है कि STATUS रजिस्टर को पढ़ने और अलग-अलग बिट्स को खोजने के लिए कौन से झंडे तय किए गए हैं। उदाहरण के लिए, अगर हमने 2 फिगर जोड़ने के बाद यह जांचना चाहा कि कैरी फ़्लैग को 1 पर सेट किया गया था, तो हम निम्नलिखित टाइप कर सकते हैं:

बीटीएफएससी 03 एच, 0
अगर 1 पर सेट किया जाता है तो यहां ले जाएं
या यहाँ अगर 0 पर सेट

यदि बिट की स्थिति एक है, तो उस स्थिति में बीटीएफएससी के बाद का निर्देश पूरा हो जाएगा। मामले में यह 0 पर सेट होता है, उस स्थिति में बाद का निर्देश छोड़ दिया जाता है। कोड का निम्नलिखित भाग प्रदर्शित करता है जिसमें इसे नियोजित किया जा सकता है:

लूप:
:
:
बीटीएफएससी 03,0
गोटो लूप

उपरोक्त कोड में, PIC केवल STATUS रजिस्टर (या कैरी फ्लैग) के केस बिट 0 में लूप से बाहर निकलेगा। इसे 0. या अन्य के रूप में परिभाषित किया गया है, गोटो कमांड संचालित किया जाएगा।

बीटीएफएसएस

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

सीएलआरएफ

यह निर्देश एक रजिस्टर के पूरे विवरण को 0. पर ठीक करेगा। वाक्य रचना है:

सीएलआरएफ
हमने CLRF 85h को लागू करके पोर्ट के आउटपुट को 0 पर सेट करने के लिए इसे पहले नियोजित किया था। इसके अलावा हमने CLRF का उपयोग करके सभी पिन को आउटपुट में शामिल करने के लिए पोर्ट को ठीक करने के लिए नियोजित किया
०५ ह।

सीएलआरडब्ल्यू

यह डब्ल्यूआरआर क्लियर को छोड़कर, सीएलआरएफ इंस्ट्रक्शन के जैसा हो सकता है। वाक्यविन्यास बहुत सरल है:

सीएलआरडब्ल्यू

आरएलएफ और आरआरएफ

ये निर्देश एक रजिस्टर में एक एकल स्लॉट को बाईं ओर (आरएलएफ) या दाएं (आरआरएफ) को एक रजिस्टर में ले जाते हैं। उदाहरण के लिए, अगर हमें 00000001 की आवश्यकता है और हमने RLF को नियोजित किया है, तो उस स्थिति में हम 00000010 के अधिकारी हो सकते हैं। इस समय, 10000000 के मामले में क्या होता है और RLF निर्देश लागू किया जाता है? निश्चित रूप से, 1 कैरी फ्लैग में तैनात होगा। यदि हम आरएलएफ निर्देश को एक बार फिर से लागू करते हैं, तो 1 शुरुआत में वापस आ जाएगा। आरआरएफ निर्देश के लिए, हालांकि, इसके विपरीत होता है। नीचे दिया गया मामला आरएलएफ निर्देश के लिए यह दर्शाता है, जिसमें हमें रजिस्टर के 8 बिट्स, साथ ही साथ ध्वज को भी देखा जा सकता है:

C 87654321
0 00000001
आरएलएफ 0 00000010
आरएलएफ 0 00000100
आरएलएफ 0 00001000
आरएलएफ 0 00010000
आरएलएफ 0 00100000
आरएलएफ 0 01000000
आरएलएफ 0 10000
आरएलएफ 1 00000000
आरएलएफ 0 00000001

उदाहरण कार्यक्रम

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

देरी लूप के लिए समय 9FH चर।
पोर्ट EQU 06H पोर्ट बी पता।
TRISB EQU 86H पोर्ट बी ट्रिस्टेट का पता।
PORTA EQU 05H पोर्ट एक पता।
TRISA EQU 85H पोर्ट ए ट्रिस्टेट एड्रेस।
STATUS EQU 03H पृष्ठ का चयन करें रजिस्टर।
COUNT1 EQU 0CH लूप रजिस्टर।
COUNT2 EQU 0DH लूप रजिस्टर।

बीएसएफ स्थिति, 5 पृष्ठ 1 पर जाएं
MOVLW 00H और सेट अप
MOVWF TRISB दोनों पोर्ट ए और बी
MOVLW 00H आउटपुट के लिए,
MOVWF TRISA तो वापस करने के लिए
बीसीएफ स्टेटस, 5 पेज 0।
MOVLW 00H क्लियर पोर्ट ए।
MOVWF दरवाजा

मुख्य कार्यक्रम की शुरुआत

RUNMOVLW
01H पहले बिटमोव सेट करें
पोर्ट B.CALL पर पोर्ट
DELAY थोड़ी देर प्रतीक्षा करें
देरी
पोर्ट बी पर थोड़ा स्थानांतरित करें, फिर रोकें ।RLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
पोर्टब, 1CALL
DELAYCALL
DELAYRLF
PORTB, 1 यह बिट को कैरी फ्लैग में ले जाता है
अब पोर्ट ए पर जाएं, और बिट को छोड़ दें ।RLF
पोर्तो, 1 यह पोर्ट फ़ेक में शून्य ध्वज से थोड़ा आगे बढ़ता है
DELAYCALL DELAYRLF
दरवाजा, 1CALL
DELAYCALL
DELAYRLF
दरवाजा, 1CALL
DELAYCALL
DELAYRLF
दरवाजा, 1CALL
DELAYCALL
देरी
पोर्ट ARRF पर थोड़ा पीछे हटें
दरवाजा, 1CALL
DELAYCALL
DELAYRRF
दरवाजा, 1CALL
DELAYCALL
DELAYRRF
दरवाजा, 1CALL
DELAYCALL
DELAYRRF
PORTA, 1 यह शून्य ध्वज में बिट को स्थानांतरित करता है अब बिट को स्थानांतरित करें
पोर्ट BRRF पर वापस
पोर्टब, 1CALL
DELAYCALL
DELAYRRF
पोर्टब, 1CALL
DELAYCALL
DELAYRRF
पोर्टब, 1CALL
DELAYCALL
DELAYRRF
पोर्टब, 1CALL
DELAYCALL DELAYRRF
पोर्टब, 1CALL
DELAYCALL
DELAYRRF
पोर्टब, 1CALL
DELAYCALL
DELAYRRF
पोर्टब, 1CALL
DELAYCALL
DELAY अब हम वापस आ गए हैं जहाँ हमने शुरुआत की थी, GOTO
रूण चलो फिर चलते हैं।

प्रशिक्षण सेट में एक बढ़िया विकल्प मौजूद है जो आपको डेटा टेबल का उपयोग करने की अनुमति देता है।

एक डेटा टेबल सिर्फ डेटा कोट्स की एक सूची है, जिसमें सभी को कुछ विचारों के आधार पर देखा जाता है।
उदाहरण के लिए, आपके पास एक सर्किट हो सकता है जो एक PIC का उपयोग करता है जो उदाहरणों की मात्रा को गिनता है एक इनपुट पिन 1 सेकंड में उच्च हो जाता है। उसके बाद आप 7 सेगमेंट डिस्प्ले पर नंबर प्रदर्शित कर सकते हैं।

जैसे ही टाइमिंग लॉन्च हुई, PIC ने उन पिनों की मात्रा गिनना शुरू कर दिया, जिन पर पिन अधिक जाती है। 1 सेकंड के बाद यह तालिका का दौरा करता है और डेटा को दिखाता है कि यह उस डिस्प्ले पर संख्या प्रदर्शित करना चाहिए जो पिन की उच्च स्थितियों का प्रतीक है। यह फायदेमंद हो सकता है, क्योंकि हम यह निर्धारित नहीं करते हैं कि चित्र क्या हो सकता है जब तक कि PIC ने अपना अनुमान पूरा नहीं किया है।

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

यह उन लोगों के लिए सुविधा प्रदान करता है जिन्होंने बेसिक में कुछ प्रोग्रामिंग का प्रदर्शन किया है। अन्यथा, आप चिंतित नहीं होंगे, आप सिद्धांत के बारे में सीखना जारी रखना चाहेंगे। संशोधन नीचे प्रस्तुत एक के समान एक बुनियादी कार्यक्रम है:

10 वर्ष K = 0
११ के = के + १
१२ इफ़ K> १० गोटो २० ईएलएसई गोटो ११
20 प्रिंट के
21 अंत

कार्यक्रम लाइन 10 से शुरू होता है। जैसे ही K 0 पर नियत होता है, यह अगली पंक्ति 11 को शुरू होता है। उसके बाद हमने 1 से K को शामिल किया, उसके बाद हम पंक्ति 12 पर जाते हैं।

इस बिंदु पर हम उत्सुक हो सकते हैं यदि K 10. से अधिक है, तो ऐसा होने पर, हम अगले पंक्ति 20 पर जाते हैं, या फिर हम पंक्ति 11 पर लौटते हैं।

लाइन 20 के के दस्तावेज, और लाइन 21 कार्यक्रम का समापन करता है। प्रोग्रामर की मदद करने के लिए BASIC लाइन के आँकड़े को नियुक्त करता है, जहाँ समस्याएँ होती हैं, उनका रिकॉर्ड रखें, क्योंकि लेबल अधिकृत नहीं हैं। PIC गंतव्यों के बीच भागने के लिए लेबल लगाती है - या क्या यह वास्तव में हो सकता है?

हम यह सुनिश्चित करने के लिए लेबल का उपयोग करते हैं कि हम इस बात से अवगत हैं कि समस्याएँ कहाँ हैं, साथ ही यह सुनिश्चित करने के लिए कि हम एक सरल तरीके से PIC को सूचित करने में सक्षम हैं जहाँ खोज की जाए।

वास्तव में क्या होता है PIC एक आंतरिक लाइन काउंटर का लाभ उठाता है जिसे प्रोग्राम काउंटर कहा जाता है। प्रोग्राम काउंटर (पीसी के लिए संक्षिप्त) मेमोरी गंतव्य का निशान जहां वर्तमान निर्देश है।

जब भी हम किसी चयनित लेबल पर जाने के लिए PIC को सूचित करते हैं, तो यह मेमोरी स्पॉट को समझता है और इसलिए पीसी को तब तक संवर्धित करता है जब तक कि वह उस मेमोरी गंतव्य को नहीं देखता। यह ठीक वैसा ही तरीका है जैसा हम ऊपर दिए गए BASIC प्रोग्राम को देखते हैं। नीचे प्रत्येक निर्देश के बगल में मेमोरी स्पेस या पीसी के आइटम के साथ कोड का एक खंड है:

पीसी इंस्ट्रक्शन0000 movlw 03
0001 movwf 0 सी
0002 लूप डिकैफ़स्क 0 सी
0003 गोटो लूप
0004 अंत

ऊपर के प्रदर्शन में, हमने पीसी को 0000 पर नियत किया है। इस पर हमारे पास निर्देश 03 हैं। जब PIC ने इस डेटा को लागू किया है, तो यह पीसी को बढ़ाता है ताकि बाद के निर्देश को स्कैन किया जा सके। इस बिंदु पर PIC को movwf 0C दिखाई देता है। पीसी फिर से बढ़ा हुआ है।

अब पीआईसी की पढ़ाई 0 सी। सी। एफ। यदि 0 सी का विवरण 0 नहीं है, तो उस स्थिति में पीसी 1 से बढ़ जाता है, साथ ही साथ निम्न निर्देश, गोटो लूप, पीसी को सूचित करता है कि वह 0003 की स्थिति में वापस आ जाए, जो कि उक्त लूप है। मामले में 0 सी का विवरण 0 है, तो पीसी को 2 से वेतन वृद्धि की सलाह दी जाती है, बस बाद के निर्देश को छोड़ दें।

डेटा टेबल्स को समझना

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

पीसी बराबर 02
Movlw 03
कॉल टेबल
:
तालिका addwf पीसी
01 को retlw
०२ की प्रतिशोध
03 को retlw
०४ का बदला लिया
05 को वापस लिया
06 को retlw
07 को retlw
वापसी

प्रारंभिक निर्देश लेबल पीसी को प्रोग्राम काउंटर (02h) के पते के साथ आवंटित कर रहा है। हम जल्द ही w रजिस्टर में 03 h का मान डालेंगे। हम उसके बाद टेबल पर संवाद करते हैं। सबरूटीन तालिका में सबसे आगे की पंक्ति प्रोग्राम काउंटर पर डब्ल्यू रजिस्टर (03 h) के विवरण को बढ़ाती है।

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

देखें मैंने रिटर्न शब्द के बाद अल्पविराम लगाया। चूँकि हम एक सबरूटीन में हैं, हमें इसकी सतह पर एक वापसी निर्देश की आवश्यकता होती है। इसलिए निर्देश में आर.ई.टी. RETLW निर्देश के बाद एक नंबर है, और यह वही है जो डब्ल्यू रजिस्टर में डाला गया है।

इस उदाहरण में यह आंकड़ा 3 है। हम डब्ल्यू रजिस्टर में किसी भी मात्रा को नामित कर सकते हैं, इसलिए जब तक यह आंकड़ा तालिका सबरूटीन में प्रोग्राम काउंटर के साथ संयुक्त हो जाता है, हम एक रिट्लाव निर्देश की खोज करने जा रहे हैं। उपर्युक्त दृष्टांत में इसका तात्पर्य है कि हम किसी भी संख्या को 1 से 7 तक रखने में सक्षम हैं। यदि हम उप-अतीत को आगे बढ़ाते हैं, तो हम कार्यक्रम के एक अतिरिक्त खंड को पूरा करने में सक्षम हो सकते हैं। इस कारण से, यह आमतौर पर PIC प्रोग्राम के अंत की ओर डेटा तालिका रखने के लिए एक स्मार्ट चाल है, इसलिए यदि हम उस मामले में ओवरशूट करते हैं तो हम किसी भी तरह कार्यक्रम के समापन पर पहुंचने वाले हैं।

बीच में आने वाला विषय अच्छी तरह से लंबा और कठिन हो सकता है।

आपको इंटरप्ट करने की कोई भी अपूर्ण विधि नहीं मिल सकती है, हालाँकि इस भाग के अंत में थोड़ी सी किस्मत के साथ आप अपने स्वयं के कार्यक्रमों में इंटरप्ट को लागू करने में सक्षम हो सकते हैं।
हमने अनुभाग को 2 चरणों में अलग किया है। यह विषय को अलग-अलग वर्गों में सक्षम करना है, साथ ही आपको आसानी से समझने के लिए एक आसान तर्क प्रदान करना है।

क्या वास्तव में एक बाधा है? निश्चित रूप से, जैसा कि शब्द से संकेत मिलता है, एक रुकावट एक तकनीक या एक संकेत है जो माइक्रोप्रोसेसर / माइक्रोकंट्रोलर को उसके प्रदर्शन से रोकती है जो कुछ भी उसके प्रदर्शन से होता है कि कुछ अलग हो सकता है।

मुझे आपको एक दैनिक चित्रण देने की अनुमति दें। लगता है कि आप अपने घर में आराम कर रहे हैं, किसी अन्य व्यक्ति से बातचीत कर रहे हैं। अचानक फोन लगता है।

आपने बात करना छोड़ दिया, और कॉलर से बात करने के लिए टेलीफोन पकड़ लिया। एक बार जब आपका टेलीफोन इंटरेक्शन हो जाता है, तो आप टेलीफोन पर आने से पहले व्यक्ति से बातचीत करने का फैसला करते हैं। किसी से चैट करते समय प्रिंसिपल रूटीन पर विचार करना संभव है, फोन बजने से आपकी बातचीत बाधित होती है, और रूटीन में ब्रेक फोन पर बोलने का तरीका है।

जब फोन चर्चा समाप्त हो जाती है, तो आप अपनी चैटिंग की प्राथमिक दिनचर्या पर वापस जाते हैं। यह दृष्टांत ठीक है कि प्रोसेसर को कार्रवाई करने के लिए कैसे बाधित किया जाए।

प्राथमिक कार्यक्रम संचालित हो रहा है, एक निश्चित कार्य को एक सर्किट में किया जाता है, हालांकि जब एक रुकावट होती है तो प्राथमिक कार्यक्रम रुक जाता है जबकि एक अलग दिनचर्या का प्रदर्शन किया जाता है। दिनचर्या समाप्त हो जाती है, प्रोसेसर पहले की तरह प्राथमिक दिनचर्या में वापस आ जाता है।

इंटरप्ट को समझना

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

क्या आपको पीआईसी के पिन-आउट की जांच करनी चाहिए, आप देखेंगे कि पिन 6 यह आरबी 0 / आईएनटी है। इस बिंदु पर, RB0 स्पष्ट रूप से पोर्ट बी बिट 0. है। INT यह दर्शाता है कि यह बाहरी रुकावट पिन के रूप में भी कॉन्फ़िगर हो सकता है। इसके अलावा, पोर्ट बी पिन 4 से 7 (पिन 10 से 13) भी इंटरप्ट के लिए उपयोग किया जा सकता है। इससे पहले कि हम INT या किसी अन्य पोर्ट B पिन को नियोजित करने में सक्षम हों, हमें दो कार्यों को पूरा करना चाहिए। बहुत पहले हमें पीआईसी को सूचित करना चाहिए कि हम इंटरप्ट का उपयोग करेंगे।

अगला, हमें यह निर्दिष्ट करना चाहिए कि कौन सा पोर्ट B पिन है जिसे हम I / O पिन के बजाय एक बाधा के रूप में उपयोग करने जा रहे हैं। PIC के अंदर आप INTCON नामक एक रजिस्टर पा सकते हैं, और पता 0Bh पर है। इस रजिस्टर में आपको 8 बिट्स की खोज होगी जो सक्षम या अक्षम हो सकती हैं। INTCON के बिट 7 को GIE के नाम से जाना जाता है। यह Global Interrngupt Enable है। इसे 1 पर ठीक करने से पीआईसी को सूचित किया जाता है कि हम एक रुकावट पैदा करेंगे।

INTCON के बिट 4 को INTE, INTerrupt Enable के रूप में जाना जाता है। इस बिट को 1 पर रखने से PIC को पता चलता है कि RB0 एक इंटरप्ट पिन होने वाला है। बिट 3 को कॉन्फ़िगर करना, जिसे RBIE कहा जाता है, PIc को सूचित करता है कि हम पोर्ट B बिट्स 4 से 7 का उपयोग करने जा रहे हैं। इस समय PIC को यह समझ में आ जाता है कि यह पिन उच्च या निम्न हो सकता है, इसे रोकना है जो यह प्रदर्शन कर रहा है और एक रुकावट के साथ आगे बढ़ना है। दिनचर्या। इस बिंदु पर, हमें पीआईसी को सूचित करना चाहिए कि क्या सम्भावना संभवतः आरोही किनारे (0V से + 5V) या ड्रापिंग एज (+ 5V से 0V) सिग्नल के परिवर्तन पर होगी।

सीधे शब्दों में कहें, तो क्या हम चाहते हैं कि PIC हर बार सिग्नल को कम से उच्च या उच्च से निम्न तक ले जाए। नाजुकता से, इसे बढ़ते किनारे पर रखा जा सकता है।

बढ़त additional ट्रिगरिंग ’एक अतिरिक्त रजिस्टर में तय की गई है जिसे विकल्प रजिस्टर कहा जाता है, पते पर 81 एच। बिट हम उत्साही हैं बिट 6 है, जिसे अक्सर INTEDG कहा जाता है।

इसे 1 पर सेट करना PIC को बढ़ते किनारे (डिफ़ॉल्ट स्थिति) पर बाधित करने के लिए ट्रिगर करता है और इसे 0 पर सेट करना PIC को स्लाइडिंग किनारे पर बाधित करने के लिए उत्तेजित करता है। यदि आप चाहते हैं कि PIC बढ़ती बढ़त पर सक्रिय हो जाए, तो आप निश्चित रूप से इस बिट के लिए कुछ भी नहीं करना है।

इस बिंदु पर, दुख की बात है कि विकल्प रजिस्टर बैंक 1 में है, जिसका अर्थ है कि हम बैंक 0 से बैंक 1 में संशोधन करने का आनंद लेते हैं, विकल्प रजिस्टर में बिट सेट करें, उसके बाद बैंक में वापस लौटें। 0. यहाँ कुंजी हर बिट को पूरा करना है। बैंक 1 एक एकल हड़ताल में पंजीकृत करता है, उदाहरण के लिए पोर्ट पिंस की स्थापना, उसके बाद बैंक 0 पर वापस लौटना यदि आप कर रहे हैं।

ठीक है, फलस्वरूप हमने PIC को सूचित कर दिया है कि कौन सा पिन संभवतः रुकावट होगा, और जहां बढ़त को ट्रिगर करना है, कार्यक्रम और PIC में किसी भी समय क्या होता है? सामान की एक जोड़ी जगह ले लो। बहुत पहले, एक 'ध्वज' निर्धारित है

यह PIC के आंतरिक प्रोसेसर को सूचित करता है कि एक रुकावट ट्रांसपायर हो गई है। अगला, प्रोग्राम काउंटर (जो मैंने पिछले ट्यूटोरियल के बारे में बात की थी) पीआईसी के भीतर एक विशिष्ट पते पर युक्तियाँ। आइए इन सभी को व्यक्तिगत रूप से देखें। इंटरप्ट फ्लैग हमारे INTCON रजिस्टर में, बिट 1 इंटरफ फ्लैग है, जिसे INTF कहा जाता है। इस बिंदु पर, जब भी कोई बाधा उत्पन्न होती है, तो यह ध्वज 1 को निश्चित हो जाएगा।

जब कोई रुकावट नहीं होती है, तो ध्वज को 0. पर रखा जाता है और साथ ही साथ यह सभी उपलब्धियों के बारे में भी होता है। इस बिंदु पर आप विचार कर सकते हैं कि the बिंदु क्या है? ’निश्चित रूप से, भले ही यह ध्वज 1 को निर्धारित किया गया हो, PIC सक्षम नहीं है, और किसी अन्य व्यवधान पर प्रतिक्रिया नहीं करेगा। इसलिए, आइए हम एक रुकावट के बारे में बताएं। संभावना है कि झंडा 1 को तय किया जाएगा, और पीआईपी रुकावट काम करने के लिए हमारी दिनचर्या में जा सकता है।

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

एक संवाद को पूरा करने की सलाह दी जाती है, फिर फोन को बाद के व्यक्ति के साथ बोलने के लिए फिर से पकड़ें। आप इस झंडे के साथ एक छोटी सी समस्या पा सकते हैं। भले ही PIC जल्दी से इस ध्वज को 1 पर सेट करता है, फिर भी इसे 0 पर सेट नहीं करता है! उस गतिविधि को प्रोग्रामर - यानी आप द्वारा प्रयोग किया जाना चाहिए। यह आसानी से पूरा किया जा सकता है, क्योंकि मैं कुछ निश्चित अनुमान लगा रहा हूं, और पीआईसी द्वारा रुकावट की दिनचर्या को पूरा करने के बाद इसे प्राप्त करने की आवश्यकता है।

मेमोरी लोकेशन जब भी आप शुरू में पीआईसी को पावर करते हैं, या यदि कोई रीसेट मौजूद है, तो प्रोग्राम काउंटर टिप्स 0000h को संबोधित करता है, जिसे प्रोग्राम मेमोरी के शुरू में immedaitely हो सकता है। लेकिन, इस घटना में एक रुकावट है, प्रोग्राम काउंटर पता 0004h इंगित करेगा।

इसलिए, जब हम अपने कार्यक्रम की रचना कर रहे हैं, जिसमें व्यवधान होगा, तो हमें सबसे पहले पीआईसी को सूचित करना होगा कि पता 0004h पर जमा करें, और बीच के शेष भाग से 0004h असतत पते पर शुरू होने वाले व्यवधान को बनाए रखें।

यह प्रदर्शन करने के लिए परेशानी मुक्त हो सकता है। प्रारंभ में, हम ओआरजी के रूप में ज्ञात एक कमांड के साथ अपना कार्यक्रम शुरू करते हैं। यह आदेश उत्पत्ति, या प्रारंभ को इंगित करता है। हम इसे एक पते के साथ चिपकाते हैं। चूंकि PIC 0000h पते पर शुरू होता है, इसलिए हम ORG 0000h टाइप करते हैं। उसके बाद हमें पता 0004h पर बायपास करना होगा। हम एक GOTO निर्देश डालकर इसे पूरा करते हैं, एक लेबल के साथ जो हमारे प्राथमिक कार्यक्रम के लिए सुझाव देता है।

उसके बाद हम एक और ओआरजी के साथ इस GOTO कमांड का पालन करते हैं, इस पल का पता 0004h है। यह इस आदेश के बाद होगा कि हम अपनी रुकावट दिनचर्या डालें। इस बिंदु पर, हम संभवतः दूसरे ओआरजी कमांड के बाद सीधे अपनी रुकावट की दिनचर्या में टाइप करने में सक्षम हो सकते हैं, या हम एक गोटो बयान देने में सक्षम हैं जो रुकावट दिनचर्या को इंगित करता है।

यह वास्तव में आपकी ओर से विकल्प से संबंधित है। पीआईसी को सूचित करने के लिए यह इंटरप्ट रूटीन के समापन पर प्रस्तुत होता है, हमें कमांड आरटीएफआई को रूटीन के अंत की स्थिति में लाना चाहिए। यह आदेश रुकावट की दिनचर्या से लौटने का संकेत देता है। जबकि PIC इस पर ध्यान देता है, प्रोग्राम काउंटर अंतिम स्थिति को इंगित करता है कि पीआईसी बाधित होने से पहले था। हमने ऊपर प्रदर्शित करने के लिए कोड के एक संक्षिप्त खंड के नीचे स्थापित किया है:

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

उदाहरण के लिए, पोर्ट ए प्राथमिक कार्यक्रम में डेटा के लिए डब्ल्यू रजिस्टर का उपयोग करने दें, इसलिए आप एक रूट से दूसरे स्थान पर डेटा को स्थानांतरित करने के लिए इंटर रजिस्टर में डब्ल्यू रजिस्टर का अतिरिक्त उपयोग कर सकते हैं।

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

जब आप इसे एक बार फिर से बाधित दिनचर्या में उपयोग करते हैं, तो इसके आस-पास का साधन समय से पहले w रजिस्टर के विवरणों को सहेजना है। दूसरा तथ्य यह है कि आप बीच में देरी का पता लगा सकते हैं जब एक बाधा उत्पन्न होती है और बाद में कोई भी उठ सकता है। जब आप समझते हैं, PIC के पास एक बाहरी घड़ी होती है, जो संभवतः एक क्रिस्टल हो सकती है या यह एक प्रतिरोध-संधारित्र कॉम्बो हो सकती है।

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

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

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

इसलिए, यदि आप इन पिनों की अनुमति देते हैं, तो संभवतः वे सभी प्राप्य हो सकते हैं। इसलिए, उदाहरण के लिए, आपके पास बिट्स 4 और 5 नहीं हैं - बिट्स 6 और 7 संभवतः एक ही समय में सशक्त होंगे। एक बाधा का प्रतिनिधित्व करने के लिए चार बिट प्राप्त करने का उद्देश्य क्या है? निश्चित रूप से, आपके पास PIC तक झुका हुआ सर्किट हो सकता है, यदि चार लाइनों में से कोई भी उच्च जाता है, तो उस स्थिति में यह एक मुद्दा हो सकता है कि आपको PIC को तुरंत प्रभावित करने की आवश्यकता होती है।

इसका एक उदाहरण होम सिक्योरिटी अलार्म हो सकता है, जिसमें चार सेंसर पोर्ट बी पिन 4 से 7. से जुड़े होते हैं। कोई भी विशिष्ट सेंसर पीआईसी को अलार्म बजाने के लिए प्रेरित कर सकता है, और अलार्म सिग्नलिंग रूटीन इंटरप्ट रुटीन है। यह बंदरगाहों की लगातार जाँच करता है और PIC को विभिन्न मामलों के साथ जारी रखने की अनुमति देता है। अगले ट्यूटोरियल के भीतर, हम एक व्यवधान को प्रबंधित करने के लिए एक प्रोग्राम बनाने जा रहे हैं।

हम अंतिम ट्यूटोरियल के भीतर बहुत सारी बुनियादी बातों से निपटते हैं, इसलिए मुझे लगता है कि अब समय आ गया है कि हम अपने पहले कार्यक्रम की रचना करें।

हम जो प्रोग्राम लिखेंगे, हम उन मौकों की मात्रा को गिनेंगे, जिन्हें हम स्विच ऑन करते हैं, और फिर संख्या प्रदर्शित करते हैं।

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

नंबर एक चीज जिसका हमें आचरण करना चाहिए, वह PIC को उस पते पर छलांग लगाने के लिए सूचित करता है जिसमें प्रोग्राम काउंटर जब भी कोई रुकावट डालता है।

आप देखेंगे कि हम हेक्साडेसिमल संख्याओं को प्रदर्शित करने का एक अनूठा तरीका नियोजित कर रहे हैं। इससे पहले कि मैं हुआ F9h लागू करें जिसमें एच ने हेक्साडेसिमल का संकेत दिया। हम इसे 0xF9 के रूप में लिख सकते हैं, यह वह संरचना है जिसे हम अभी से नियोजित करने जा रहे हैं।

अब हमें पीआईसी को यह बताने की आवश्यकता है कि हम इंटरप्ट का उपयोग करने जा रहे हैं, और हम रुब पिन 6 का उपयोग एक बाधा पिन के रूप में कर रहे हैं:

bsf INTCON, 7GIE - वैश्विक व्यवधान सक्षम (1 = सक्षम)
bsf INTCON, 4INTE - RB0 इंटरप्ट इनेबल (1 = इनेबल)
मैं केवल मामले में बाधा झंडा को साफ़ करने जा रहा हूँ (मुझे कभी भी किसी चीज़ पर भरोसा नहीं है!)
bcf INTCON, 1INTF - केवल मामले में ध्वज को साफ़ करें

वर्तमान में हमें अपने 2 पोर्ट स्थापित करने होंगे। ध्यान रखें कि अब हम एक रुकावट पिन के रूप में RB0 का उपयोग कर रहे हैं, इसे एक इनपुट के रूप में स्थापित करने की आवश्यकता है:

हम स्विच काउंट की संख्या को संग्रहीत करने के लिए COUNT नामक एक चर का उपयोग करने जा रहे हैं। हम केवल पोर्ट ए पर मूल्य बढ़ा सकते हैं, लेकिन आप देखेंगे कि जब हम अपनी रुकावट दिनचर्या लिखते हैं तो मैं एक चर का उपयोग क्यों कर रहा हूं।

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

फिर भी, हम केवल 0 से 9 तक स्विच के कितने अवसरों को दिखाना चाहते हैं। ऊपर, मैंने कहा कि हम पोर्ट ए पर हर बार एक वेतन वृद्धि को रोकने में सक्षम हो सकते हैं। हालाँकि, पोर्ट ए में 5 बिट्स हैं, अगर हम पोर्ट को बढ़ाते हैं, तो हम 31 की उच्चतम गिनती के अधिकारी होंगे। स्पष्टीकरण के एक जोड़े हैं कि मैंने 31 को स्थानांतरित करने के लिए क्यों नहीं चुना।

प्रारंभ में, हम एक 7-खंड स्क्रीन को नियोजित करेंगे, जो कि केवल 0 से 15 (हेक्स में एफ से एफ) तक ही जा सकता है। इसके बाद, मैं आपको कुछ अंकगणित आज्ञाओं को दिखाना चाहता हूं, जिन्हें आपने पिछले कुछ पाठों में पढ़ा था।

इसलिए हम अपनी रुकावट दिनचर्या के साथ जारी रखेंगे। वर्तमान में सबसे पहले जो हमें पूरा करना चाहिए वह हमारे w रजिस्टर के विवरणों को संक्षेप में संग्रहीत करना है, क्योंकि हम COUNT को PORTA में स्थानांतरित करने के लिए इसे लागू कर रहे हैं। यदि हम इसे नहीं बचाते हैं, तो उस स्थिति में हम अपने अंकगणित के कारण पूरी तरह से अलग संख्या देने में सक्षम हो सकते हैं। इसलिए पहले यह पूरा होने दें:

इस बिंदु पर हम समझते हैं कि यदि COUNT का मूल्य 9 या अधिक है। अभी हमें जो पूरा करने की आवश्यकता है, यदि COUNT 9 से अधिक है, तो इसे 0 पर वापस रखें, अन्यथा मुख्य कार्यक्रम पर वापस जाएं ताकि हम यह सुनिश्चित कर सकें कि हम इसे पोर्ट ए। BTFSS कमांड में वितरित कर सकते हैं क्योंकि आप समझते हैं कि बाद में होगा।
कैरी फ़्लैग के मामले में निर्देश यानि COUNT = 10:

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

हर बार जब आप स्विच को सक्रिय करते हैं, तो एलईएन 0000 से 1010 तक बाइनरी में गिने जा रहे हैं, फिर वापस 0000 पर।

निम्नलिखित आंकड़ा ऊपर वर्णित कोड के साथ संगत सर्किट आरेख दिखाता है। दिलचस्प रूप से आप पाएंगे कि डिजाइन में टाइमिंग कैपेसिटर को शामिल किया गया है। यह एक छोटा सा काम है, जिसके माध्यम से आपको उस समय के दौरान संधारित्र को शामिल करने से बचने की स्वतंत्रता मिलती है, उस समय आपके साथ कोई भी नहीं होता है।

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

एक और खंड जो सर्किट में देखा जा सकता है, वह है स्विच के पार नेटवर्क। यह यांत्रिक स्विचिंग के दौरान हस्तक्षेप को रोकता है और यदि स्विचिंग एक एकल टॉगल या एकाधिक टॉगल था, तो PIC को भ्रमित होने से रोकता है।