NodeMCU एक इंटरैक्टिव फर्मवेयर है , जो ESP8266 माइक्रोकंट्रोलर ( ESP32 समर्थन विकास में है) पर Lua दुभाषिया चलाने की अनुमति देता है। सभी नियमित हार्डवेयर इंटरफेस के साथ, इसमें वाईफाई मॉड्यूल और SPIFFS फाइल सिस्टम है।

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

चालक मॉडल मूल बातें

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

DEVICES + DRIVERS | +-----+ | +-----+ |1WIRE<----------------------+1WIRE| ++-+-++ | +-----+ | | | | +---------+ | +--------+ | +------+ | | | +------+DS1820| +---v----+ +---v----+ +---v----+ | | +------+ |DS1820|0| |DS1820|1| |DS1822|0| | | +---^----+ +---^----+ +---^----+ | | +------+ | | +--------------+DS1822| | | | | +------+ +-----------+------------------+ + 

डिवाइस ड्राइवर दिए गए डिवाइस के साथ जुड़े तर्क का एक टुकड़ा है। चालक द्वारा प्रदान किए गए कार्यों को विधियां कहा जाता है , चालक से जुड़े डेटा कंटेनरों को विशेषता कहा जाता है । दोनों विधियाँ और विशेषताएँ ड्राइवर के अंदर रहती हैं।

गुण उनके साथ जुड़े दो कार्य हैं: गेटटर और सेटर हुक। तो सुपरसेट विधि कार्यक्षमता का गुण है, लेकिन वे अधिक मेमोरी भी लेते हैं (माइक्रोकंट्रोलर मेमोरी दुर्लभ है, याद रखें?)।

 sdm.attr_add(drv, -- device handle "ref", -- attribute name "Reference voltage", -- attribute description 5, function(dev) -- this is a getter function return sdm.attr_data(sdm.attr_handle(dev, "ref")) end, function(dev, value) -- this is a setter function sdm.attr_set(sdm.attr_handle(dev, "ref"), value) end ) 

डिवाइस बाइंडिंग

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

_poll() मिलान तर्क में ड्राइवरों में _poll() नाम से _poll() । यह एक नियमित विधि है जिसे डिवाइस हैंडल के साथ पैरामीटर के रूप में कहा जाता है और यह true या false अगर डिवाइस क्रमशः ड्राइवर के साथ संलग्न या नहीं किया जा सकता है।

 sdm.method_add(drv, "_poll", nil, function(dev, drv, par) local attr = sdm.attr_data(sdm.local_attr_handle(dev, "id")) -- get device attribute "id" if attr == nil then return false end -- if it does not have one, driver does not match -- parent name must be "ESP8266_1W" and first byte of "id" must be "0x28" return (sdm.device_name(par) == "ESP8266_1W") and (attr:byte(1) == 0x28) end ) 

जैसा कि ऊपर दिए गए उदाहरण में देखा गया है, ड्राइवर विशेषता का उपयोग करके डिवाइस से मेल खाता है। लेकिन जैसा कि ऊपर उल्लेख किया गया है, विशेषताएँ केवल चालक के साथ जुड़ती हैं। आम तौर पर यह सच है, लेकिन कुछ विशेषताएं हैं जिन्हें सॉफ्टवेयर के माध्यम से पुनर्प्राप्त नहीं किया जा सकता है। ये चिप आईडी, प्रयुक्त पिन आदि हैं। उन लोगों के लिए एक विशेष प्रकार की विशेषता को sdm - स्थानीय विशेषता में जोड़ा गया था। यह विशेषता डिवाइस के एक उदाहरण से जुड़ी होती है और आमतौर पर अपरिवर्तनीय होती है।

ड्राइवर बाइंडिंग के बारे में केवल एक ही बात कहना बाकी है। आमतौर पर उपकरणों को उपयोग के बाद स्टार्टअप और क्लीनअप पर किसी प्रकार के आरंभीकरण की आवश्यकता होती है। इस प्रयोजन के लिए _init() और _free() विधियों का उपयोग करता है।
यदि ड्राइवर में _init() विधि है तो इसे डिवाइस बाइंडिंग के बाद स्वचालित रूप से कहा जाएगा। _free() ।

 sdm.method_add(drv, "_init", nil, function(dev, drv, par) sdm.device_rename(dev, sdm.request_name("DS18B20")) -- rename device sdm.attr_copy(dev, "temp") -- copy attribute sdm.attr_copy(dev, "precision") -- copy attribute local met = sdm.method_dev_handle(par, "setup") -- get 1Wire bus pin init function .. local func = sdm.method_func(met) -- .. and .. func(par, dev) -- .. call it end ) sdm.method_add(drv, "_free", nil, function(dev, drv, par) local met = sdm.method_dev_handle(par, "free") -- get 1Wire bus pin free function .. local func = sdm.method_func(met) -- .. and .. func(par, dev) -- .. call it end ) 

चौकस पाठक शायद पूछेंगे: क्या मतलब ऊपर उदाहरण में "प्रतिलिपि विशेषता" है? और वह सही होगा, क्योंकि यह तीसरे प्रकार की विशेषता के साथ करना है जिसे हमने अभी तक चर्चा नहीं की है - निजी विशेषता । सभी डिवाइस इंस्टेंस के बीच सभी विशेषता डेटा साझा करने के लिए बहुत अधिक समझ में नहीं आता है। इस प्रयोजन के लिए sdm ड्राइवर से विशेषता की प्रतिलिपि बनाने का तंत्र प्रदान करता है और इसे उपकरण के साथ जोड़ता है। यह ड्राइवर को एक प्रोटोटाइप या टेम्पलेट बनाता है।

एक त्वरित सारांश:

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

वेब यूजर इंटरफेस कार्यान्वयन

सर्वर कोड

वहाँ एक सुंदर nodemcu-httpserver परियोजना है जो NudeMCU के लिए सर्वर कोड लागू करता है। अफसोस की बात है कि यह मर चुका है। यह सर्वर के लिए एक आधार के रूप में इस्तेमाल किया गया था। सबसे पहले, सर्वर फ़ंक्शन को LFS में ले जाया गया और फिर हर कॉल के लिए एक स्थिर पृष्ठ पर काम करने के लिए थोड़ा संशोधित किया गया। Vue.js टेम्पलेट आधारित वेब पृष्ठों के लिए एक आदर्श विकल्प है। इसलिए इसका इस्तेमाल फ्रंटेंड के लिए किया गया था। यह ध्यान देने योग्य है कि NodeMCU इंटरनेट से जुड़ा नहीं हो सकता है। इस वजह से, vue.js लाइब्रेरी को स्थानीय रूप से मौजूद रहने और NodeMCU सर्वर द्वारा सेवा प्रदान करने की आवश्यकता है।

चूंकि सभी उपकरण पेड़ की संरचना में व्यवस्थित होते हैं, इसलिए उन्हें एक निर्देशिका की तरह एक्सेस किया जाता है: /ESP8266/ESP8266_1W/DS18S20-0 । यहाँ /ESP8266 एक NodeMCU पेज है, /ESP8266/ESP8266_1W वायर बस पेज है और अंत में /ESP8266/ESP8266_1W/DS18S20-0 तापमान सेंसर है।

जैसा कि पहले उल्लेख किया गया है, सभी डिवाइस पृष्ठ एक टेम्पलेट पेज से निर्मित होते हैं जो हर कॉल पर परोसा जाता है। इस पृष्ठ के अंदर JS कोड उसी URL के लिए अनुरोध करता है, जो /api साथ prepended है। ऊपर दिए गए उदाहरण के लिए कॉल URL /api/ESP8266/ESP8266_1W/DS18S20-0 । ऐसे अनुरोधों पर सर्वर JSON -encoded डिवाइस-विशिष्ट डेटा के साथ प्रतिक्रिया करता है, जो पेज को पॉप्युलेट करता है। बेशक, HTML पेज अनुरोध को छोड़ दिया जा सकता है यदि केवल कच्चे डेटा की जरूरत है।

उपकरण का पेड़

प्रारंभिक डिवाइस कॉन्फ़िगरेशन सरल डिवाइस ट्री संरचना का उपयोग करके किया जाता है। यह डिवाइस ट्री की तरह है , लेकिन सरल है। यह डिवाइस की स्थानीय विशेषताओं सहित हार्डवेयर के विन्यास का वर्णन करता है।

 local root={ -- local_attributes={}, children={ { name="ESP8266_1W", -- local_attributes={}, children = { { name="DS18S20-0", -- static declaration alternative to 1Wire poll method local_attributes={ { name="id", desc=nil, -- empty description to save space data=string.char(16) .. string.char(221) .. string.char(109) .. string.char(104) .. string.char(3) .. string.char(8) .. string.char(0) .. string.char(150) -- ugly way to create byte array }, { datapin=2 } } }, } }, { name="ESP8266_SPI", -- local_attributes={}, children = { { name="MCP3208-0" }, } }, } } 

हार्डवेयर सेटअप

यहां से शुरू होता है प्रदर्शन। इस प्रयोजन के लिए सेंसर का एक गुच्छा NodeMCU से जुड़ा था:

• DS18B20 तापमान सेंसर
• DS18S20 तापमान सेंसर
• MCP3208 ADC

1वायर सेंसर एक ही पिन से जुड़े होते हैं।

वेब पेज और ड्राइवर

रूट डिवाइस

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

यह कोड स्निपेट यहां से है :

 sdm.method_add(drv, "_init", nil, function(dev, drv, par) local attr = sdm.attr_handle(dev, "id") -- get device "id" attribute sdm.attr_set(attr, node.chipid()) -- set "id" value attr = sdm.attr_handle(dev, "float") -- get device "float" attribute sdm.attr_set(attr, 3 / 2 ~= 1) -- set to true if firmware supports floating point instructions end ) sdm.attr_add(drv, "float", "Floating point build", false, function(drv) -- attribute value is set inside "_init" function local attr = sdm.attr_drv_handle(drv, "float") return sdm.attr_data(attr) -- just return stored value end, nil ) 

यह कोड विशेषता float जोड़ता है जो फर्मवेयर बिल्ड प्रकार को रखने के लिए उपयोग किया जाता है। इसका मान _init() हुक में आरंभीकृत किया गया है जो एक विशेष कार्य है, जो एक बार तब चलता है जब ड्राइवर डिवाइस से जुड़ता है।

यह रूट डिवाइस के लिए जनरेट किया गया पेज है।

यहां हम देख सकते हैं कि रूट डिवाइस में एक विधि heap , दो ड्राइवर विशेषताएँ float और id । अंत में, इसमें दो डिवाइस जुड़े हुए हैं - एसपीआई और 1 वायर बसें।

एसपीआई

SPI ड्राइवर बहुत दिलचस्प नहीं है। यह सिर्फ NodeMCU SPI फ़ंक्शन को मैप करता है।

MCP3208

MCP3208 एक ADC चिप है। यह 12 बिट कोड को रेफरी और रिटर्न शून्य से वोल्टेज मापता है। इस ड्राइवर के कार्यान्वयन के बारे में दिलचस्प यह है कि विशेषता ref केवल तभी मौजूद होगी जब फर्मवेयर फ़्लोटिंग पॉइंट अंकगणित का समर्थन करता है। यदि यह समर्थित नहीं है, तो निरपेक्ष वोल्टेज के बजाय, वोल्टेज कोड single और differential दोनों तरीकों से वापस आ जाता है।

 sdm.method_add(drv, "single", "Single ended measure 0|1|2|3|4|5|6|7", function(dev, channel) -- ... if ref ~= nil then -- this part is executed only if floating point arithmetic is enabled rv = ref * rv / 4096 end return rv end ) if 3/2~=1 then -- other alternative is to access ESP8266 "float" method sdm.attr_add(drv, "ref", "Reference voltage", 5, function(dev) return sdm.attr_data(sdm.attr_handle(dev, "ref")) end, function(dev, value) sdm.attr_set(sdm.attr_handle(dev, "ref"), value) end ) end 

यह भी ध्यान दें कि इस उपकरण में विशेषता ref को निजी के रूप में चिह्नित किया गया है। यह प्रति उपकरण के आधार पर सेट किया गया है।

1wire

1 चालक चालक poll विधि लागू करता है - उपकरणों के लिए गतिशील खोज ।

डिवाइस की खोज के ठीक बाद इसके प्रकार का पता नहीं चल पाया है। तो इसका 1 वायर अद्वितीय पता एक नए डिवाइस के नाम के रूप में उपयोग किया जाता है (बाइट्स को _ वर्ण द्वारा अलग किए गए संख्याओं के रूप में दर्शाया जाता है)।

 sdm.method_add(drv, "poll", "Poll for devices", function(bus, pin) local children = sdm.device_children(bus) or {} -- already attached local ids = {} -- get IDs of attached devices for name, handle in pairs(children) do local dpin = sdm.attr_data(sdm.local_attr_handle(handle, "pin")) if dpin == pin then ids[sdm.attr_data(sdm.local_attr_handle(handle, "id"))] = true end end ow.reset_search(pin) -- reset previous search while true do -- for all found devices local id = ow.search(pin) if id == nil then break end if ids[id] == nil then -- if not already present local name = "" for i=1,#id do name = name .. tostring(id:byte(i)) .. "_" end name = name:sub(1,-2) -- add to system with their ID used as name local device = sdm.device_add(name, bus) -- add "pin" attribute local rv = sdm.local_attr_add(device, "datapin", nil, pin, nil, nil) -- add "id" attribute local rv = sdm.local_attr_add(device, "id", nil, id, nil, nil) -- poll for driver local rv = sdm.device_poll(device) end end end ) 

यह 1Wire ड्राइवर के लिए प्रारंभिक पृष्ठ है।

तर्क 2 और ताज़ा पृष्ठ के साथ poll कॉल जारी करने के बाद, बच्चे अनुभाग दिखाई देता है। ध्यान दें कि बच्चों के नाम मानव पठनीय हैं। ऐसा इसलिए है क्योंकि device_rename() फ़ंक्शन को उनके _init दौरान बुलाया गया था।

DS18S20

प्रारंभ होने पर, DS18S20 ड्राइवर जाँचता है कि डिवाइस ID 0x10 शुरू होता है, जो एक डिवाइस परिवार कोड है। जब डिवाइस को ड्राइवर से जोड़ा जाता है, तो इसका नाम बदलकर DS18S20-X दिया जाता है, जहां DS18S20 एक DS18S20 है और X एक इंस्टेंस नंबर है।

 sdm.method_add(drv, "_poll", nil, function(dev, drv, par) local attr = sdm.attr_data(sdm.local_attr_handle(dev, "id")) if attr == nil then return false end return (sdm.device_name(par) == "ESP8266_1W") and (attr:byte(1) == 0x10) -- check family ID end ) sdm.method_add(drv, "_init", nil, function(dev, drv, par) sdm.device_rename(dev, sdm.request_name("DS18S20")) -- rename device sdm.attr_copy(dev, "temp") -- copy attribute to device local met = sdm.method_dev_handle(par, "setup") local func = sdm.method_func(met) -- use parent "setup" method on the device func(par, dev) end ) 

स्थानीय विशेषताओं id और datapin और setter हुक नहीं होते हैं, इसलिए केवल उनके नाम दिखाई देते हैं।

DS18B20

DS18B20 ड्राइवर लगभग DS18S20 ड्राइवर के समान है। एकमात्र अंतर precision विधि है। दोनों DS18; 20 ड्राइवर पूर्णांक बिल्ड मान लेते हैं और फ्लोटिंग पॉइंट डिवीजन का उपयोग नहीं करते हैं।

 sdm.attr_add(drv, "precision", "Precision (9|10|11|12)", 12, function(dev, precision) local attr = sdm.attr_dev_handle(dev, "precision") return sdm.attr_data(attr) end, function(dev, precision) local par = sdm.device_parent(dev) local attr = sdm.attr_dev_handle(dev, "precision") local ex = sdm.method_func(sdm.method_dev_handle(par, "exchange")) local modes = {[9]=0x1f, [10]=0x3f, [11]=0x5f, [12]=0x7f} if modes[precision] ~= nil then ex(par, dev, {0x4e, 0, 0, modes[precision]}) sdm.attr_set(attr, precision) end end ) 

मेमोरी का उपयोग

ESP8266 मुफ्त मेमोरी लगभग 40k है । सर्वर कोड को LFS में स्थानांतरित कर दिया गया है, इसलिए यह आरंभीकरण समय पर कोई रैम स्थान नहीं लेता है ( मूल कोड लगभग 10k लिया गया)।

एसडीएम 5 डिवाइस चालकों और 5 उपकरणों के लिए लगभग 10k लेता है। गैर-फ़्लोटिंग फ़र्मवेयर बिल्ड के लिए थोड़ा कम। इसलिए हाथ में कार्य के लिए केवल ड्राइवर के लिए ड्राइवर का चयन करना बेहतर होता है । सबसे अधिक स्मृति लेने वाला कार्य vue.js लाइब्रेरी की सेवा vue.js है।

कच्चे JSON -encoded डेटा ( curl का उपयोग करके) का अनुरोध करने के मामले में शिखर मेमोरी की खपत काफी कम हो सकती है।

एक उपसंहार के बजाय

पहले तरीकों में से एक जिसे मैंने sdm के साथ लागू किया था, उसके लिए बाध्यकारी था
node.restart() ।
वेब उपयोगकर्ता इंटरफ़ेस का उपयोग करके इसे आज़माने से एक उत्सुक परिणाम उत्पन्न हुआ। वेब ब्राउज़र द्वारा अनुरोध जारी किए जाने के ठीक बाद, चिप को फिर से शुरू किया गया। लेकिन क्योंकि NodeMCU ने HTTP रिक्वेस्ट का ठीक से जवाब नहीं दिया, इसलिए वेब ब्राउज़र ने फिर से वही अनुरोध करने की कोशिश की। जब NodeMCU सर्वर पुनः आरंभ हुआ और फिर से चालू हुआ, तो ब्राउज़र इससे जुड़ा, आंतरिक प्रयास फिर से काउंटर पर रीसेट करें और node.restart() कहलाता है।