इस बार मैंने एहतियात के तौर पर अपनी बाइक में जीपीएस ट्रैकर छिपाने के बारे में सोचा। कार, ​​कार्गो, साइकिल, सामान, बच्चों और जानवरों पर नज़र रखने के लिए बाजार पर कई स्वायत्त उपकरण हैं। उनमें से अधिकांश एसएमएस के माध्यम से उपयोगकर्ता के साथ बातचीत करते हैं। अधिक महंगे विकल्प मेरे फोन की कार्यक्षमता का पता लगाते हैं, लेकिन एक विशिष्ट ऑनलाइन सेवा से जुड़े होते हैं।
आदर्श रूप से, मैं ट्रैकर पर पूर्ण नियंत्रण रखना चाहता हूं: एसएमएस और पंजीकरण के बिना इसे सुविधाजनक मोड में उपयोग करें। सतही गूगल ने मुझे चीन से कुछ मॉड्यूल लाए, जिनमें से एक मैंने ऑर्डर किया (ए 9 जी पुडिंग बोर्ड) (~ $ 15)।

यह लेख इस बारे में है कि मैंने इस मॉड्यूल पर अजगर का काम कैसे किया।

यदि ए 9 जी ईएसपी का एक एनालॉग है (निर्माता, वैसे, एक ही है), तो पुडिंग बोर्ड स्वयं एनओडीएमसीयू बोर्ड का एक एनालॉग है, सिवाय इसके कि पुडिंग बोर्ड में एक अंतर्निहित यूएसबी-यूएआर कनवर्टर नहीं है। लेकिन कई अन्य दिलचस्प चीजें हैं। निर्माता विनिर्देशों:

• 32 बिट कोर (RISC), 312MHz तक
• 29x GPIO (सभी हल किए गए हैं, सभी इंटरफेस इस संख्या में शामिल हैं)
• घड़ी और घड़ी
• 1x USB 1.1 इंटरफ़ेस (मुझे यह वहां नहीं मिला, लेकिन ऑफसाइट से कॉपी) और पावर के लिए माइक्रोयूएसबी
• 2x UART (+1 सेवा)
• 2x एसपीआई (आजमाया नहीं गया)
• 3x I2C (कोशिश नहीं की गई)
• 1x एसडीएमएमसी (भौतिक स्लॉट के साथ)
• 2x एनालॉग इनपुट (10 बिट्स, संभवतः उनमें से एक लिथियम बैटरी नियंत्रकों द्वारा उपयोग किया जाता है)
• 4Mb फ़्लैश
• 4 एमबी पीएसआरएएम
• एडीसी (माइक्रोफोन, बोर्ड पर भौतिक रूप से मौजूद है) और डीएसी (स्पीकर, अनुपस्थित)
• बैटरी चार्ज नियंत्रक (कोई बैटरी ही नहीं है)
• वास्तव में, एसएमएस, आवाज और जीपीआरएस के साथ जीएसएम (800, 900, 1800, 1900 मेगाहर्ट्ज)
• UART2 के माध्यम से जीपीएस जुड़ा हुआ है (इसके बिना "A9" मॉड्यूल है)
• सिम स्लॉट (नैनो)
• दो बटन (एक रीसेट, अन्य - समावेशन और प्रोग्राम करने योग्य फ़ंक्शन)
• दो एल.ई.डी.

ऑपरेटिंग वोल्टेज 3.3V है, इनपुट वोल्टेज 5-3.8V (कनेक्शन के आधार पर) है। सामान्य तौर पर, मॉड्यूल में एक साधारण पुश-बटन मोबाइल डिवाइस से इकट्ठा करने के लिए सभी आवश्यक हार्डवेयर होते हैं। लेकिन उदाहरणों से, ऐसा लगता है कि चीनी इसे स्लॉट मशीनों या स्लॉट मशीनों या कुछ इस तरह से बिक्री के लिए खरीद रहे हैं। मॉड्यूल के विकल्प बल्कि लोकप्रिय SIM800 मॉड्यूल हैं, जो दुर्भाग्य से, सार्वजनिक डोमेन में एसडीके नहीं है (यानी मॉड्यूल एटी मॉडेम के रूप में बेचे जाते हैं)।

एसडीके

मॉड्यूल संतोषजनक अंग्रेजी में एसडीके के साथ आता है। उबंटू के तहत स्थापित करता है, लेकिन विंडोज और कंटेनर पसंद किए जाते हैं। GUI में पोकिंग के माध्यम से सब कुछ काम करता है: इस मॉड्यूल के लिए ESPtool को अभी तक वापस नहीं लाया गया है। फर्मवेयर खुद मेकफाइल द्वारा बनाया गया है। डीबगर मौजूद है: ठंड से पहले, मॉड्यूल स्टैक ट्रेस को सेवा पोर्ट में फेंकता है। लेकिन व्यक्तिगत रूप से, मैं कोड की पंक्तियों में पते का अनुवाद नहीं कर सका (जीडीबी रिपोर्ट बताती है कि पते किसी भी चीज़ के अनुरूप नहीं हैं)। यह संभव है कि यह लिनक्स के लिए खराब समर्थन के कारण है। तदनुसार, यदि आप मॉड्यूल के साथ टिंकर करना चाहते हैं - तो इसे विंडोज के तहत करने की कोशिश करें (और जीथब पर अनसब्सक्राइब करें)। अन्यथा, यहां लिनक्स के लिए निर्देश है। स्थापना के बाद, आपको सभी CSDTK/lib/libQt* में .bashrc और delete (rename) पथों की शुद्धता की जांच करने की आवश्यकता है: अन्यथा, Flasher (उर्फ डिबगर) बस एक विवाद के कारण शुरू नहीं होगा, शायद, स्थापित libQt।

फ्लैशर के लिए एक निर्देश है ।

संबंध

NodeMCU की तुलना में सब कुछ अधिक जटिल है। मॉड्यूल समान दिखते हैं, लेकिन पुडिंग बोर्ड पर कोई USB-TTY चिप नहीं है और माइक्रोयूएसबी केवल शक्ति के लिए उपयोग किया जाता है। तदनुसार, आपको 3.3V पर USB-TTY की आवश्यकता होगी। दो बेहतर हैं: एक डीबग पोर्ट के लिए और एक UART1 के लिए: पहला फर्मवेयर अपलोड करने के लिए उपयोग किया जाता है और दूसरा आप एक नियमित टर्मिनल के रूप में उपयोग कर सकते हैं। इन सभी स्नोट को कंप्यूटर पर नहीं खींचने के लिए, मैंने इसके अलावा दो-मीटर केबल और एक बाहरी बिजली की आपूर्ति (आवश्यक) के साथ 4-पोर्ट यूएसबी स्प्लिटर खरीदा है। मॉड्यूल के साथ इस किट की कुल लागत $ 25-30 (बिजली की आपूर्ति के बिना: फोन से उपयोग) होगी।

प्रविष्टि

मॉड्यूल AT फर्मवेयर के साथ आता है: आप 3.3V arduino से कनेक्ट कर सकते हैं और इसे UART1 के माध्यम से मॉडेम के रूप में उपयोग कर सकते हैं। उनका फर्मवेयर सी में लिखा गया है। दो फ़र्मवेयर फ़ाइलें make : एक को लगभग एक मिनट के लिए सीवन किया जाता है, दूसरा तेजी से पर्याप्त होता है। इन फ़ाइलों में से केवल एक को सीवन किया जा सकता है: पहली बार बड़ी है, बाद की समय सीमा छोटी है। कुल मिलाकर, विकास प्रक्रिया के दौरान, मेरे पास मॉड्यूल, मिनिटर्म को stdio और कोड संपादक के रूप में प्रबंधित करने के लिए डेस्कटॉप पर चीनी एसडीके ( coolwatcher ) खुला है।

एपीआई

एपीआई की सामग्री ऊपर की सूची को दर्शाती है और इसके शुरुआती दिनों में ईएसपी 8266 जैसा दिखता है: हैलोवर्ल्ड को लॉन्च करने में मुझे लगभग 3 घंटे लगे। दुर्भाग्य से, उपयोगकर्ता के लिए उपलब्ध फ़ंक्शन का सेट बहुत सीमित है: उदाहरण के लिए, सिम कार्ड पर फोन बुक तक पहुंच नहीं है, सेलुलर नेटवर्क से कनेक्ट होने के बारे में निम्न-स्तरीय जानकारी, और इसी तरह। एपीआई प्रलेखन भी कम पूर्ण है, इसलिए आपको उदाहरणों पर भरोसा करना होगा (जिनमें से दो दर्जन हैं) और फाइलें शामिल हैं। फिर भी, मॉड्यूल एसएसएल कनेक्शन तक बहुत सारी चीजें कर सकता है: जाहिर है, निर्माता ने सबसे अधिक प्राथमिकता वाले कार्यों पर ध्यान केंद्रित किया है।

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

micropython

माइक्रोपायथॉन एक ओपन-सोर्स प्रोजेक्ट है जो cPython को माइक्रोकंट्रोलर्स को पोर्ट करता है। विकास दो दिशाओं में किया जाता है। पहले सभी माइक्रोकंट्रोलरों को कॉमन लाइब्रेरीज़ का समर्थन और विकास आम है जो कि अजगर में मुख्य डेटा प्रकारों के साथ काम करने का वर्णन करता है: ऑब्जेक्ट्स, फ़ंक्शंस, क्लासेस, स्ट्रिंग्स, परमाणु प्रकार, और बहुत कुछ। दूसरा, वास्तव में, बंदरगाहों: प्रत्येक माइक्रोकंट्रोलर के लिए यह आवश्यक है कि वह इनपुट-आउटपुट के लिए UART के साथ काम करने के लिए लाइब्रेरी को "सिखाए", वर्चुअल मशीन के लिए एक स्टैक का चयन करें, अनुकूलन का एक सेट निर्दिष्ट करें। वैकल्पिक रूप से, हार्डवेयर के साथ काम का वर्णन किया गया है: GPIO, पावर, वायरलेस, फाइल सिस्टम।
यह सब मैक्रो के साथ शुद्ध सी में लिखा गया है: माइक्रोपाइथन में रोम में मॉड्यूल लिखने के लिए स्ट्रिंग की घोषणा करने से अनुशंसित व्यंजनों का एक सेट है। इसके अलावा, अजगर स्व-लिखित मॉड्यूल पूरी तरह से समर्थित हैं (मुख्य बात स्मृति आकार के बारे में नहीं भूलना है)। परियोजना के क्यूरेटर अपने लक्ष्य के रूप में एक dzhanga (रोटी की रोटी के साथ चित्र) लॉन्च करने का अवसर निर्धारित करते हैं । एक विज्ञापन के रूप में: प्रोजेक्ट अपने बोर्ड को छात्रों के लिए बेचता है, लेकिन ESP8266 और ESP32 मॉड्यूल के लिए पोर्ट भी लोकप्रिय हैं।

जब फर्मवेयर तैयार हो जाता है और अपलोड किया जाता है - आप बस UART के माध्यम से माइक्रोकंट्रोलर से कनेक्ट होते हैं और पायथन आरईपीएल में पहुंचते हैं।

 $ miniterm.py /dev/ttyUSB1 115200 --raw MicroPython cd2f742 on 2017-11-29; unicorn with Cortex-M3 Type "help()" for more information. >>> print("hello") hello 

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

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

कहां से शुरू करें

सबसे पहले, micropython/ports जाएं और micropython/ports micropython/ports/minimal को नए फ़ोल्डर में कॉपी करें जहां पोर्ट स्थित होगा। फिर, अपने मंच के लिए main.c संपादित करें। ध्यान रखें कि सभी mp_init() main फ़ंक्शन में हैं, जहां आपको mp_init() इनिशियलाइज़र को कॉल करने की आवश्यकता होती है, पहले से इसके लिए माइक्रोकंट्रोलर और स्टैक सेटिंग्स तैयार करने की आवश्यकता होती है। फिर, ईवेंट-चालित एपीआई के लिए, आपको pyexec_event_repl_init() कॉल करने की आवश्यकता है और UART के माध्यम से दर्ज किए गए वर्णों को pyexec_event_repl_process_char(char) फ़ंक्शन में फ़ीड करना होगा। यह आरईपीएल के माध्यम से इंटरऑपरेबिलिटी प्रदान करेगा। दूसरी फ़ाइल, micropython/ports/minimal/uart_core.c UART में ब्लॉकिंग इनपुट और आउटपुट का वर्णन करती है। मैं उन लोगों के लिए STM32 के लिए मूल कोड लाता हूं जो देखने के लिए बहुत आलसी हैं।

main.c

 int main(int argc, char **argv) { int stack_dummy; stack_top = (char*)&stack_dummy; #if MICROPY_ENABLE_GC gc_init(heap, heap + sizeof(heap)); #endif mp_init(); #if MICROPY_ENABLE_COMPILER #if MICROPY_REPL_EVENT_DRIVEN pyexec_event_repl_init(); for (;;) { int c = mp_hal_stdin_rx_chr(); if (pyexec_event_repl_process_char(c)) { break; } } #else pyexec_friendly_repl(); #endif //do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT); //do_str("for i in range(10):\r\n print(i)", MP_PARSE_FILE_INPUT); #else pyexec_frozen_module("frozentest.py"); #endif mp_deinit(); return 0; } 

uart_core.c

 // Receive single character int mp_hal_stdin_rx_chr(void) { unsigned char c = 0; #if MICROPY_MIN_USE_STDOUT int r = read(0, &c, 1); (void)r; #elif MICROPY_MIN_USE_STM32_MCU // wait for RXNE while ((USART1->SR & (1 << 5)) == 0) { } c = USART1->DR; #endif return c; } // Send string of given length void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) { #if MICROPY_MIN_USE_STDOUT int r = write(1, str, len); (void)r; #elif MICROPY_MIN_USE_STM32_MCU while (len--) { // wait for TXE while ((USART1->SR & (1 << 7)) == 0) { } USART1->DR = *str++; } #endif } 

उसके बाद, आपको निर्माता से सिफारिशों / संकलक का उपयोग करके मेकफाइल को फिर से लिखना होगा: यहां सब कुछ व्यक्तिगत है। सब कुछ, यह आदर्श रूप से पर्याप्त होना चाहिए: हम इकट्ठा करते हैं, फ़र्मवेयर में भरते हैं और UART में REPL को देखते हैं।
micropython को पुनर्जीवित करने के बाद micropython आपको इसकी भलाई की देखभाल करने की आवश्यकता है: कचरा संग्रहकर्ता, Ctrl-D की सही प्रतिक्रिया (नरम रीसेट) और कुछ अन्य चीजें जो मैं उस पर नहीं mpconfigport.h : mpconfigport.h फ़ाइल देखें।

एक मॉड्यूल बनाएँ

सबसे दिलचस्प बात अपने स्वयं के मॉड्यूल लिख रही है। तो, मॉड्यूल (आवश्यक नहीं, लेकिन वांछनीय) अपने स्वयं के mod[].c फ़ाइल के साथ शुरू होता है, जिसे SRC_C ( SRC_C चर यदि आप सम्मेलन का पालन करते हैं) द्वारा जोड़ा जाता है। एक खाली मॉड्यूल इस प्रकार है:

 // nlr - non-local return:  C  ,      goto-  . //  nlr_raise             . #include "py/nlr.h" //   .  ,  mp_map_elem_t,  ,   . #include "py/obj.h" //   . mp_raise_ValueError(char* msg)  mp_raise_OSError(int errorcode)   . //  ,   mp_call_function_*     Callable (  callback-). #include "py/runtime.h" #include "py/binary.h" //  header   :       #include "portmodules.h" //    --  .     MP_QSTR_[ ]. MP_OBJ_NEW_QSTR   . //             RAM. //      -      __name__ STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, }; //      STATIC MP_DEFINE_CONST_DICT (mp_module_mymodule_globals, mymodule_globals_table); //   :             const mp_obj_module_t mp_module_mymodule = { .base = { &mp_type_module }, .globals = (mp_obj_dict_t*)&mp_module_mymodule_globals, }; 

बेशक, पोर्ट स्वयं mp_module_mymodule पहचानता नहीं है: इसे mpconfigport.h पोर्ट mpconfigport.h में MICROPY_PORT_BUILTIN_MODULES चर में जोड़ा जाना चाहिए। वैसे बोरिंग वॉलपेपर चिप नाम और बंदरगाह का नाम भी वहाँ बदल जाते हैं। इन सभी परिवर्तनों के बाद, आप मॉड्यूल को संकलित करने और इसे REPL से आयात करने का प्रयास कर सकते हैं। मॉड्यूल नाम के साथ केवल एक __name__ विशेषता मॉड्यूल के लिए उपलब्ध होगी (टैब के माध्यम से REPL में ऑटो-पूर्णता की जांच के लिए एक बड़ा मामला)।

 >>> import mymodule >>> mymodule.__name__ 'mymodule' 

स्थिरांक

जटिलता में अगला चरण स्थिरांक जोड़ रहा है। सेटिंग्स ( INPUT , OUTPUT , HIGH , LOW , आदि) के लिए स्थिरांक अक्सर आवश्यक होते हैं। यहां सब कुछ काफी सरल है। यहाँ, उदाहरण के लिए, निरंतर magic_number = 10 :

 STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, }; 

परीक्षण:

 >>> import mymodule >>> mymodule.magic_number 10 

कार्यों

किसी फ़ंक्शन को मॉड्यूल में जोड़ना सामान्य सिद्धांत का पालन करता है: घोषित करें, लपेटें, जोड़ें (मैं प्रलेखन की तुलना में थोड़ा अधिक जटिल उदाहरण देता हूं)।

 //  STATIC mp_obj_t conditional_add_one(mp_obj_t value) { //   int.         -  :   . int value_int = mp_obj_get_int(value); value_int ++; if (value_int == 10) { //  None return mp_const_none; } //   int return mp_obj_new_int(value); } //    .     // runtime.h   . STATIC MP_DEFINE_CONST_FUN_OBJ_1(conditional_add_one_obj, conditional_add_one); //  STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj }, }; 

टेस्ट:

 >>> import mymodule >>> mymodule.conditional_add_one(3) 4 >>> mymodule.conditional_add_one(9) >>> 

कक्षाएं (प्रकार)

कक्षाओं (प्रकार) के साथ, सब कुछ भी अपेक्षाकृत सरल है। यहाँ प्रलेखन से एक उदाहरण है (अच्छी तरह से, लगभग):

 //     STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = {}; //   STATIC MP_DEFINE_CONST_DICT(mymodule_hello_locals_dict, mymodule_hello_locals_dict_table); // ,  ,   const mp_obj_type_t mymodule_helloObj_type = { //    { &mp_type_type }, // : helloObj .name = MP_QSTR_helloObj, //  .locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, }; //    STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&mymodule_helloObj_type }, }; 

टेस्ट:

 >>> mymodule.helloObj <type 'helloObj'> 

परिणामी प्रकार को विरासत में दिया जा सकता है, तुलना की जा सकती है, लेकिन इसमें एक निर्माता या कोई संबद्ध डेटा नहीं है। डेटा को कंस्ट्रक्टर के साथ "बगल में" जोड़ा जाता है: यह एक अलग संरचना बनाने का प्रस्ताव है जिसमें पायथन प्रकार को अलग और अलग से संग्रहीत किया जाएगा - एक मनमाना डेटा सेट।

 //  -. ,    typedef struct _mymodule_hello_obj_t { //   mp_obj_base_t base; // -  uint8_t hello_number; } mymodule_hello_obj_t; 

इस डेटा के साथ बातचीत कैसे करें? सबसे कठिन तरीकों में से एक निर्माणकर्ता के माध्यम से है।

 // -,   (,  ,   mymodule_helloObj_type //   ,     - ),   (args  kwargs)  //        : args, kwargs STATIC mp_obj_t mymodule_hello_make_new( const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args ) { //    mp_arg_check_num(n_args, n_kw, 1, 1, true); //   mymodule_hello_obj_t *self = m_new_obj(mymodule_hello_obj_t); //     self->base.type = &mymodule_hello_type; //   self->hello_number = mp_obj_get_int(args[0]) //   return MP_OBJ_FROM_PTR(self); //    __init__, ,  } //      make_new const mp_obj_type_t mymodule_helloObj_type = { { &mp_type_type }, .name = MP_QSTR_helloObj, .locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, //  .make_new = mymodule_hello_make_new, }; 

अन्य क्षेत्रों में, वहाँ भी है .print , और मैं .print के बाकी जादू का Python3 ।

लेकिन make_new किसी वस्तु का एक उदाहरण प्राप्त करने के लिए आवश्यक नहीं है: आरंभीकरण एक अनियंत्रित फ़ंक्शन में किया जा सकता है। यहाँ micropython/ports/esp32/modsocket.c से एक अच्छा उदाहरण है:

 //   :       STATIC mp_obj_t get_socket(size_t n_args, const mp_obj_t *args) { socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t); sock->base.type = &socket_type; sock->domain = AF_INET; sock->type = SOCK_STREAM; sock->proto = 0; sock->peer_closed = false; if (n_args > 0) { sock->domain = mp_obj_get_int(args[0]); if (n_args > 1) { sock->type = mp_obj_get_int(args[1]); if (n_args > 2) { sock->proto = mp_obj_get_int(args[2]); } } } sock->fd = lwip_socket(sock->domain, sock->type, sock->proto); if (sock->fd < 0) { exception_from_errno(errno); } _socket_settimeout(sock, UINT64_MAX); return MP_OBJ_FROM_PTR(sock); } //     0-3  STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_socket_obj, 0, 3, get_socket); 

बंधे हुए तरीके

अगला कदम बाध्य तरीकों को जोड़ना है। हालांकि, यह अन्य सभी तरीकों से बहुत अलग नहीं है। हम प्रलेखन से उदाहरण पर लौटते हैं:

 //    :     1 (self) STATIC mp_obj_t mymodule_hello_increment(mp_obj_t self_in) { mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in); self->hello_number += 1; return mp_const_none; } //     MP_DEFINE_CONST_FUN_OBJ_1(mymodule_hello_increment_obj, mymodule_hello_increment); //      'inc' STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_inc), (mp_obj_t)&mymodule_hello_increment_obj }, } 

यह बात है!

 >>> x = mymodule.helloObj(12) >>> x.inc() 

अन्य सभी विशेषताएं: गेटैट , सेटट्रा

गैर-कार्यों को जोड़ने के बारे में, @property और आम तौर पर अपने खुद के __getattr__ का उपयोग कैसे करें? कृपया: यह मैन्युअल रूप से mymodule_hello_locals_dict_table को दरकिनार करके किया जाता है।

 //     ... STATIC void mymodule_hello_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in); if (dest[0] != MP_OBJ_NULL) { // __setattr__ if (attr == MP_QSTR_val) { self->val = dest[1]; dest[0] = MP_OBJ_NULL; } } else { // __getattr__ if (attr == MP_QSTR_val) { dest[0] = self->val; } } } // ...     attr const mp_obj_type_t mymodule_helloObj_type = { { &mp_type_type }, .name = MP_QSTR_helloObj, //     //.locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, .make_new = mymodule_hello_make_new, //   - attr .attr = mymodule_hello_attr, }; 

आप कहते हैं कि कुछ दर्दनाक रूप से संक्षिप्त attr निकला। ये सभी mp_raise_AttributeError ( नोट : ऐसा फ़ंक्शन मौजूद नहीं है) कहां हैं? वास्तव में, एक AttributeError को स्वचालित रूप से कहा जाएगा। रहस्य यह है कि dest दो तत्वों की एक सरणी है। पहले तत्व का अर्थ है "आउटपुट", राइट-ओनली: यह मान लेता है MP_OBJ_SENTINEL अगर मूल्य को MP_OBJ_SENTINEL है और MP_OBJ_NULL अगर इसे पढ़ने की आवश्यकता है। तदनुसार, फ़ंक्शन से बाहर निकलने पर, पहले मामले में mp_obj_t है और दूसरे में कुछ mp_obj_t । दूसरा तत्व इनपुट है, केवल पढ़ने के लिए: वस्तु का मूल्य लिखने के लिए लेता है अगर मूल्य को लिखने की आवश्यकता है और MP_OBJ_NULL अगर इसे पढ़ने की आवश्यकता है। आपको इसे बदलने की आवश्यकता नहीं है।

बस इतना ही, आप देख सकते हैं:

 >>> x = mymodule.helloObj(12) >>> x.val = 3 >>> x.val 3 

सबसे दिलचस्प यह है कि REPL में पूरा होने वाला टैब अभी भी काम करता है और ऑफर करता है। ईमानदार होने के लिए, मैं C का विशेषज्ञ नहीं हूं, इसलिए मैं केवल यह अनुमान लगा सकता हूं कि ऐसा कैसे होता है (ऑपरेटर == को फिर से परिभाषित करके)।

बंदरगाह

ए 9 जी मॉड्यूल पर लौटते हुए, मैंने सभी बुनियादी कार्यों, एसएमएस, जीपीआरएस (यूप्स), जीपीएस, पावर मैनेजमेंट के समर्थन का वर्णन किया । अब आप मॉड्यूल पर कुछ इस तरह अपलोड कर सकते हैं और यह काम करेगा:

 import cellular as c import usocket as sock import time import gps import machine #   print("Waiting network registration ...") while not c.is_network_registered(): time.sleep(1) time.sleep(2) #  GPRS print("Activating ...") c.gprs_activate("internet", "", "") print("Local IP:", sock.get_local_ip()) #  GPS gps.on() #    thingspeak host = "api.thingspeak.com" api_key = "some-api-key" fields = ('latitude', 'longitude', 'battery', 'sat_visible', 'sat_tracked') #  ,      ! fields = dict(zip(fields, map(lambda x: "field{}".format(x+1), range(len(fields))) )) x, y = gps.get_location() level = machine.get_input_voltage()[1] sats_vis, sats_tracked = gps.get_satellites() s = sock.socket() print("Connecting ...") s.connect((host, 80)) print("Sending ...") #      ,     HTTP.           HTTP, SSL   print("Sent:", s.send("GET /update?api_key={}&{latitude}={:f}&{longitude}={:f}&{battery}={:f}&{sat_visible}={:d}&{sat_tracked}={:d} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n".format( api_key, x, y, level, sats_vis, sats_tracked, host, **fields ))) print("Receiving ...") print("Received:", s.recv(128)) s.close() 

परियोजना किसी भी संभव मदद का स्वागत करती है। यदि आपको प्रोजेक्ट और / या यह लेख पसंद आया है, तो गीथब पर लाइक छोड़ना न भूलें।