एक Arduino पर एक EEPROM में डेटा की बचत

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

मान लीजिए कि हमारे पास एक चर है और हम इसे एक EEPROM में संग्रहीत करना चाहते हैं। ऐसा लगता है कि इसके लिए सभी उपकरण हमारे हाथ में हैं:

#include <EEPROM.h> int my_var = DEFAULT_VALUE; EEPROM.get(MY_VAR_ADDR, my_var); my_var = NEW_VALUE; EEPROM.put(MY_VAR_ADDR, my_var); 

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

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

2. माना कि हम संदेश की शुद्धता के बारे में आश्वस्त थे, लेकिन मैं यह कैसे सुनिश्चित कर सकता हूं कि यह वह था जिसने इसे लिखा था ( प्रामाणिकता की गारंटी के लिए)। जैसा कि कहा जाता है, मैं अलग हूं। अचानक, मेरे पुनर्जन्म से पहले कोई और इस टेबल पर बैठा था, और उसके पास एक अलग मिशन था, और मैं अब किस कारण से उसके संदेशों से निर्देशित होऊंगा? यदि हम एक निश्चित लेबल के साथ अपने नोट्स प्रदान करते हैं, तो हमारे लिए अजनबियों से अलग पहचान बनाना आसान होगा। उदाहरण के लिए, ऐसा लेबल उस चर का नाम हो सकता है जिसे हम सहेज रहे हैं। एकमात्र समस्या यह है कि EEPROM में चर नाम रखने के लिए बहुत जगह नहीं है, और इसे करने के लिए असुविधाजनक है, क्योंकि वे अलग-अलग लंबाई के हैं। लेकिन सौभाग्य से एक सरल तरीका है - आप चर की ओर से चेकसम की गणना कर सकते हैं और इसे शॉर्टकट के रूप में उपयोग कर सकते हैं। इसी समय, बाइट्स में चर के आकार को इस चेकसम में जोड़ना उपयोगी है, ताकि गलती से गलत राशि को न पढ़ें। खैर, पूर्णता के लिए, हम एक और संख्यात्मक पहचानकर्ता जोड़ते हैं, ताकि हमारे चर को किसी और से अलग करने की गारंटी दी जा सके, भले ही उन्हें समान कहा जाए। हम इस संख्या को उदाहरण पहचानकर्ता (OOP द्वारा प्रेरित अगर चर नाम वस्तु क्षेत्र के रूप में माना जाता है) कहते हैं। यदि हम कभी भी अपने मिशन को एक मौलिक रूप से नए संस्करण में अपग्रेड करते हैं, ताकि यह अपडेट उन सभी चीज़ों के बारे में जानकर बेहोश कर दे जो पुराने सहेजे गए हैं, तो हमें बस पुराने संस्करण द्वारा सहेजे गए सभी चीज़ों को अमान्य करने के लिए उदाहरण पहचानकर्ता को बदलने की आवश्यकता है।

3. मैं पुराने संग्रहित मूल्य को अधूरा लिखने के ऑपरेशन को कैसे अपरिवर्तित कर सकता हूं? यही है, सेव ऑपरेशन या तो सफल होना चाहिए, या इसका बिल्कुल भी अवलोकन प्रभाव नहीं होना चाहिए। दूसरे शब्दों में, यह परमाणु या लेन-देन होना चाहिए, अगर हम एक लेनदेन के बारे में बात कर रहे हैं जो एकल मूल्य के बिना शर्त अद्यतन के लिए आता है। जाहिर है, हम पिछले मूल्य को फिर से लिखना करके रिकॉर्ड की परमाणुता सुनिश्चित नहीं कर सकते हैं, हमें एक नई जगह पर लिखना होगा ताकि पुराने संग्रहीत मूल्य बरकरार रहें, कम से कम नए की रिकॉर्डिंग पूरी होने तक। इस तकनीक को अक्सर 'कॉपी-ऑन-राइट' कहा जाता है यदि सहेजे गए मूल्य का केवल एक हिस्सा अपडेट किया जाता है, लेकिन जो हिस्सा अपरिवर्तित रहता है उसे अभी भी कॉपी किया जाता है और एक नए स्थान पर लिखा जाता है। अपने सादृश्य को विकसित करते हुए, हम अपने आप को पत्र लिखेंगे, पुराने लोगों को अछूता छोड़ देंगे, लेकिन प्रत्येक पत्र की बढ़ती सीरियल संख्या के साथ आपूर्ति करेंगे ताकि हमारे अगले जीवन में हमारे द्वारा लिखे गए अंतिम पत्र को खोजने का अवसर मिले। उसी समय, हालांकि, एक नई समस्या पैदा होती है - बॉक्स में जगह जहां हम अक्षर डालते हैं, वह जल्दी या बाद में समाप्त हो जाएगी यदि हम पुराने अक्षरों को फेंक नहीं देते हैं जो अप्रासंगिक हो गए हैं। यह समझना आसान है कि यह केवल 2 अक्षरों को संग्रहीत करने के लिए पर्याप्त है - एक पुराना और एक नया, यह लेखन की प्रक्रिया में हो सकता है। तदनुसार, अक्षर संख्या को भी कई बिट्स की आवश्यकता नहीं है।

विचित्र रूप से पर्याप्त है, लेखक अखंडता, प्रामाणिकता और परमाणुता सुनिश्चित करते हुए EEPROM में डेटा भंडारण के संगठन की अनुमति देने वाले एक भी कार्यान्वयन को खोजने में असमर्थ था। मुझे स्वयं github.com/olegv142/NvTx पर लिखना था

EEPROM में प्रत्येक चर को बचाने के लिए, 2 लगातार क्षेत्रों का उपयोग किया जाता है - समान संरचना वाले सेल। इसके आकार, पाठ लेबल और उदाहरण पहचानकर्ता के आधार पर गणना किए गए चर की पहचानकर्ता पहले 2 बाइट्स में लिखा गया है। इसके बाद, डेटा लिखा जाता है, जिसके बाद चेकसम के 2 बाइट्स होते हैं। पहले बाइट में, दो बिट्स का एक विशेष उद्देश्य होता है। सबसे महत्वपूर्ण बिट शुद्धता ध्वज है; लिखते समय, इसे हमेशा एक पर सेट किया जाता है। कम-क्रम बिट का उपयोग युग की एकल-बिट संख्या के रूप में किया जाता है, इसे अंतिम संदेश खोजने के लिए आवश्यक है। रिकॉर्डिंग 'एक सर्कल में' कोशिकाओं में की जाती है। पहली बार सेल में रिकॉर्ड किए जाने पर हर बार युग संख्या में परिवर्तन होता है। इसलिए अंतिम रिकॉर्ड किए गए सेल को निर्धारित करने के लिए एल्गोरिथ्म: यदि कोशिकाओं के युग समान हैं, तो दूसरा अंतिम लिखा जाता है, यदि अलग - फिर पहला।

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

जो लोग कार्यान्वयन विवरण में तल्लीन करना चाहते हैं, वे चित्र और कोड को रिपॉजिटरी में देख सकते हैं। मैं, पाठक को बोर न करने के लिए, उपयोग करने के लिए आगे बढ़ता हूं। डेटा लिखने / पढ़ने के कार्यों को प्रत्येक 5 पैरामीटर प्राप्त होते हैं, इसलिए उनके उपयोग की सुविधा लचीलेपन के पक्ष में बलिदान की जाती है। लेकिन यह मैक्रोज़ के दो सेटों द्वारा उदारता से भरपाई की जाती है, जो कि EEPROM.get / put के मामले में पुस्तकालय का सरल उपयोग करते हैं। मैक्रोज़ के पहले सेट का उपयोग तब किया जाता है जब आप दिए गए पते पर चर को बचाना चाहते हैं:

 #include <NvTx.h> int my_var = DEFAULT_VALUE; bool have_my_var = NvTxGetAt(my_var, MY_VAR_ADDR); my_var = NEW_VALUE; NvTxPutAt(my_var, MY_VAR_ADDR); 

यदि सहेजे जाने वाले कई चर हैं, तो प्रत्येक को पता निर्धारित करना होगा और उसी समय सही ढंग से आकार पर विचार करना होगा ताकि स्मृति क्षेत्र जहां चर संग्रहीत हैं, ओवरलैप न हों। कार्य को सरल बनाने के लिए, मैक्रोज़ का दूसरा सेट स्वचालित पता आवंटन को लागू करता है, और यह संकलन समय पर करता है। उदाहरण के लिए, Arduino-EEPROMEx लाइब्रेरी रनटाइम पर मेमोरी आवंटित कर सकती है, जबकि यह प्रत्येक संग्रहीत चर के लिए RAM में पता संग्रहीत करता है। NvTx लाइब्रेरी EEPROM में निष्पादन योग्य कोड या रैम की सामग्री के साथ कुछ भी जोड़े बिना स्थान आवंटित करता है।

 #include <NvTx.h> int my_var = DEFAULT_VALUE; char my_string[16] = ""; NvPlace(my_var, MY_START_ADDR, MY_INST_ID); NvAfter(my_string, my_var); bool have_my_var = NvTxGet(my_var); my_var = NEW_VALUE; NvTxPut(my_var); 

NvPlace मैक्रो EEPROM क्षेत्र के शुरुआती पते को सेट करता है, जहां हम चर और उदाहरण पहचानकर्ता को संग्रहीत करेंगे। NvAfter मैक्रो मेमोरी का एक क्षेत्र रखता है जो मेमोरी के क्षेत्र को दूसरे के लिए आरक्षित करने के तुरंत बाद अपना पहला तर्क संग्रहीत करता है। मेमोरी आवंटित करते समय, यह भी सत्यापित किया जाता है कि हम उपलब्ध EEPROM आकार से आगे नहीं गए, और यह भी कि हमने ओवरलैपिंग मेमोरी क्षेत्रों को आरक्षित नहीं किया (यदि ऐसा हो सकता है कि दो NvAfter मैक्रोज़ का दूसरा तर्क हो)। दो निर्दिष्ट शर्तों में से किसी के उल्लंघन के मामले में, कार्यक्रम बस संकलन नहीं करता है। जो लोग मेमोरी आवंटन तंत्र से निपटना चाहते हैं वे इसे NvTx.h हेडर फाइल में पाएंगे । सभी NvPlace और NvAfter मैक्रोज़ करते हैं, गणना को परिभाषित करते हैं, जो चर नामों के आधार पर अपने नाम बनाते हैं, और संकलन समय मुखर के बहुत उपयोगी मुहावरेदार निर्माण का भी उपयोग करते हैं ।

उम्मीद है कि एनवीटीएक्स पुस्तकालय पाठकों को विश्वसनीय, औद्योगिक-ग्रेड कोड लिखने में मदद करेगा।