👨🏿‍🤝‍👨🏼 ☝🏿 👩🏻‍🔧 हम माइक्रोकंट्रोलर (stm32) के लिए प्रोजेक्ट में Lua दुभाषिया को एम्बेड करते हैं 🕚 🤳🏼 👩‍✈️

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

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

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

मैंने लूआ को स्क्रिप्टिंग भाषा के रूप में चुना।

क्यों लुआ?

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

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

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

उस परियोजना के बारे में जिसमें लुआ सन्निहित होगा

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

यह परियोजना 1 एमबी गैर-वाष्पशील और 192 KB RAM (128 KB की कुल क्षमता वाले पुराने 2 ब्लॉक) के साथ stm32f405rgt6 माइक्रोकंट्रोलर पर आधारित है।

हार्डवेयर पेरिफेरल इन्फ्रास्ट्रक्चर को सपोर्ट करने के लिए प्रोजेक्ट में फ्रीआरटीओएस रियल-टाइम ऑपरेटिंग सिस्टम है। कार्यों के लिए सभी मेमोरी, सेमाफोर और अन्य फ्रीआरटीओएस ऑब्जेक्ट्स को लिंकिंग स्टेज (रैम के .bs क्षेत्र में स्थित) पर स्टैटिकली आवंटित किया जाता है। सभी फ्रीआरटीओएस इकाइयां (सेमाफोर्स, क्वीज, टास्क स्टैक, आदि) अपनी कक्षाओं के निजी क्षेत्रों में वैश्विक वस्तुओं का हिस्सा हैं। हालांकि, फ्रीआरटीओएस ढेर को अभी भी मॉलोक, मुफ्त , कॉलोक फ़ंक्शन ( प्रिंटफ जैसे कार्यों के लिए आवश्यक) का समर्थन करने के लिए आवंटित किया गया है जो इसके साथ काम करने के लिए पुनर्परिभाषित हैं। माइक्रोएसडी (FatFS) कार्ड के साथ काम करने के लिए एक उठाया एपीआई है, साथ ही UART (115200, 8N1) को डीबग करना है।

एक परियोजना के हिस्से के रूप में लुआ का उपयोग करने के तर्क के बारे में

व्यावसायिक तर्क को डीबग करने के उद्देश्य से, यह माना जाता है कि आदेशों को UART द्वारा भेजा जाएगा, एक अलग वस्तु के रूप में (तैयार ऑब्जेक्ट के रूप में) पैक किया गया (वर्ण "\ n" + 0-टर्मिनेटर के साथ समाप्त) और लुआ मशीन को भेजा गया। असफल निष्पादन के मामले में, प्रिंटफ के माध्यम से आउटपुट (क्योंकि यह पहले परियोजना में शामिल था)। जब तर्क डिबग किया जाता है, तो माइक्रोएसडी कार्ड से फ़ाइल से अंतिम व्यावसायिक तर्क फ़ाइल डाउनलोड करना संभव होगा (इस लेख की सामग्री में शामिल नहीं)। इसके अलावा, लुआ को डिबग करने के उद्देश्य से, मशीन को एक अलग फ्रीआरटीओएस थ्रेड के अंदर निष्पादित किया जाएगा (भविष्य में, प्रत्येक डिबग्ड बिजनेस लॉजिक स्क्रिप्ट के लिए एक अलग धागा आवंटित किया जाएगा जिसमें इसे अपने पर्यावरण के साथ निष्पादित किया जाएगा)।

परियोजना में लुआ पनडुब्बी का समावेश

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

CMakeLists निम्न सबमॉडल संकलन झंडे (मुख्य परियोजना में सबमॉड्यूल कॉन्फ़िगरेशन फ़ाइल से लिया गया) के साथ एक स्थिर पुस्तकालय के रूप में लुआ भंडार के स्रोतों का निर्माण करता है:

SET(C_COMPILER_FLAGS "-std=gnu99;-fshort-enums;-fno-exceptions;-Wno-type-limits;-ffunction-sections;-fdata-sections;") SET(MODULE_LUA_COMP_FLAGS "-O0;-g3;${C_COMPILER_FLAGS}"

और उपयोग किए गए प्रोसेसर के विनिर्देश के झंडे ( रूट CMakeLists में सेट):

 SET(HARDWARE_FLAGS -mthumb; -mcpu=cortex-m4; -mfloat-abi=hard; -mfpu=fpv4-sp-d16;)

यह महत्वपूर्ण है कि रूट CMakeLists की परिभाषा को निर्दिष्ट करने की आवश्यकता पर ध्यान दें जो दोहरे मान का उपयोग न करने की अनुमति देता है (क्योंकि माइक्रोकंट्रोलर के पास दोहरे के लिए हार्डवेयर समर्थन नहीं है। केवल फ्लोट):

 add_definitions(-DLUA_32BITS)

खैर, यह केवल लिंकर को इस पुस्तकालय को इकट्ठा करने की आवश्यकता के बारे में सूचित करने और अंतिम परियोजना के लेआउट में परिणाम शामिल करने के लिए बना हुआ है:

CMakeLists एक परियोजना को लुआ लाइब्रेरी के साथ जोड़ने की साजिश रचते हैं

 add_subdirectory(${CMAKE_SOURCE_DIR}/bsp/submodules/module_lua) ... target_link_libraries(${PROJECT_NAME}.elf PUBLIC # -Wl,--start-group       #      . #  Lua    ,      #  . "-Wl,--start-group" ..._... MODULE_LUA ..._... "-Wl,--end-group")

स्मृति के साथ काम करने के लिए कार्य को परिभाषित करना

चूँकि Lua स्वयं मेमोरी से संबंधित नहीं है, इसलिए यह जिम्मेदारी उपयोगकर्ता को हस्तांतरित की जाती है। हालाँकि, जब बंडल लॉक्सलिब लाइब्रेरी और luaL_newstate फ़ंक्शन का उपयोग किया जाता है, तो l_alloc फ़ंक्शन मेमोरी सिस्टम के रूप में बाध्य होता है। इसे निम्नानुसार परिभाषित किया गया है:

 static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { (void)ud; (void)osize; /* not used */ if (nsize == 0) { free(ptr); return NULL; } else return realloc(ptr, nsize); }

जैसा कि लेख की शुरुआत में उल्लेख किया गया है, परियोजना ने पहले ही मॉलोक और मुक्त कार्यों को ओवरराइड कर दिया है, लेकिन कोई वास्तविक कार्य नहीं है। हमें इसे ठीक करने की जरूरत है।

FreeRTOS हीप के साथ काम करने के लिए मानक तंत्र में, प्रोजेक्ट में उपयोग की गई heap_4.c फ़ाइल में पहले से आवंटित मेमोरी ब्लॉक को आकार देने के लिए कोई फ़ंक्शन नहीं है। इस संबंध में, इसका कार्यान्वयन मॉलॉक और मुफ्त के आधार पर करना आवश्यक है।

चूंकि भविष्य में मेमोरी आवंटन योजना (एक और heap_x.c फ़ाइल का उपयोग करके) को बदलना संभव है, यह वर्तमान योजना (heap_4.c) के अंदरूनी का उपयोग नहीं करने का निर्णय लिया गया था, लेकिन एक उच्च-स्तरीय ऐड-इन बनाने के लिए। हालांकि कम प्रभावी है।

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

यदि इस तथ्य को ध्यान में नहीं रखा जाता है, तो आपकी मशीन इस तरह की स्क्रिप्ट को लाइन " ए = 3 \ n " से तीन बार निष्पादित करने में सक्षम होगी, जिसके बाद यह एक कठिन गलती में गिर जाएगी। हार्ड गलती हैंडलर में रजिस्टरों की अवशिष्ट छवि का अध्ययन करने के बाद समस्या का हल किया जा सकता है, जिससे यह पता लगाना संभव होगा कि इंटरप्रेटर कोड और उसके पुस्तकालयों के आंतों में टेबल का विस्तार करने की कोशिश करने के बाद दुर्घटना हुई। यदि आप " प्रिंट 'टेस्ट' जैसी स्क्रिप्ट कहते हैं, तो फर्मवेयर फ़ाइल कैसे इकट्ठी होती है (दूसरे शब्दों में, व्यवहार अपरिभाषित है) के आधार पर व्यवहार बदल जाएगा।

पुराने ब्लॉक से नए पर डेटा कॉपी करने के लिए, हमें पुराने ब्लॉक के आकार का पता लगाना होगा। FreeRTOS heap_4.c (अन्य फ़ाइलों की तरह जो ढेर से निपटने के तरीके प्रदान करता है) इसके लिए एक एपीआई प्रदान नहीं करता है। इसलिए, आपको अपना खत्म करना होगा। एक आधार के रूप में, मैंने vPortFree फ़ंक्शन को लिया और इसकी कार्यक्षमता को निम्न रूप में काट दिया:

VPortGetSizeBlock फ़ंक्शन कोड

 int vPortGetSizeBlock (void *pv) { uint8_t *puc = (uint8_t *)pv; BlockLink_t *pxLink; if (pv != NULL) { puc -= xHeapStructSize; pxLink = (BlockLink_t *)puc; configASSERT((pxLink->xBlockSize & xBlockAllocatedBit) != 0); configASSERT(pxLink->pxNextFreeBlock == NULL); return pxLink->xBlockSize & ~xBlockAllocatedBit; } return 0; }

अब यह मॉलॉक , मुक्त और vPortGetSizeBlock के आधार पर छोटा, वास्तविक लिखना है :

मॉलॉक, मुक्त और vPortGetSizeBlock के आधार पर Realloc कार्यान्वयन कोड

 void *realloc (void *ptr, size_t new_size) { if (ptr == nullptr) { return malloc(new_size); } void* p = malloc(new_size); if (p == nullptr) { return p; } size_t old_size = vPortGetSizeBlock(ptr); size_t cpy_len = (new_size < old_size)?new_size:old_size; memcpy(p, ptr, cpy_len); free(ptr); return p; }

स्टडआउट के साथ काम करने के लिए समर्थन जोड़ें

जैसा कि यह आधिकारिक विवरण से ज्ञात हो जाता है, लुआ दुभाषिया स्वयं I / O के साथ काम करने में सक्षम नहीं है। इन उद्देश्यों के लिए, मानक पुस्तकालयों में से एक जुड़ा हुआ है। आउटपुट के लिए, यह stdout स्ट्रीम का उपयोग करता है। मानक पुस्तकालय से luaopen_io फ़ंक्शन स्ट्रीम से कनेक्ट करने के लिए ज़िम्मेदार है। स्टडआउट ( प्रिंटफ के विपरीत) के साथ काम करने का समर्थन करने के लिए, आपको फाइटाइट फ़ंक्शन को ओवरराइड करना होगा। मैंने पिछले लेख में वर्णित कार्यों के आधार पर इसे फिर से परिभाषित किया।

Fiteite फ़ंक्शन

 size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream) { stream = stream; size_t len = size * count; const char *s = reinterpret_cast<const char*>(buf); for (size_t i = 0; i < len; i++) { if (_write_char((s[i])) != 0) { return -1; } } return len; }

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

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

Mc_fflush फ़ंक्शन

 int mc_fflush () { uint32_t len = buf_p; buf_p = 0; if (uart_1.tx(tx_buf, len, 100) != mc_interfaces::res::ok) { errno = EIO; return -1; } return 0; }

एक सीरियल पोर्ट से स्ट्रिंग्स को पुनः प्राप्त करना

एक लुआ मशीन के लिए तार प्राप्त करने के लिए, मैंने एक साधारण यूर्ट-टर्मिनल क्लास लिखने का फैसला किया, जो:

एक सीरियल पोर्ट बाइट-बाइट पर डेटा प्राप्त करता है (बीच में);
प्राप्त बाइट को कतार में जोड़ता है, जहां धारा इसे प्राप्त करती है;
बाइट्स की एक धारा में, यदि यह एक पंक्ति फ़ीड नहीं है, तो इसे उस रूप में वापस भेजा जाता है जिसमें यह आया था;
अगर एक लाइन फीड आ गया है (' \ r '), तो टर्मिनल कैरिज रिटर्न के 2 बाइट भेजे जाते हैं (" \ n \ r ");
प्रतिक्रिया भेजने के बाद, बाइट का हैंडलर जो आया (लाइन लेआउट ऑब्जेक्ट) कहा जाता है;
हटाए गए वर्ण कुंजी को दबाने पर नियंत्रण (टर्मिनल विंडो से सेवा वर्ण हटाने से बचने के लिए);

सूत्रों का लिंक:

UART वर्ग इंटरफ़ेस यहाँ है ;
UART बेस क्लास यहाँ और यहाँ है ;
यहाँ और यहाँ वर्ग uart_terminal;
यहां प्रोजेक्ट के हिस्से के रूप में एक क्लास ऑब्जेक्ट बनाना।

इसके अतिरिक्त, मैं ध्यान देता हूं कि इस ऑब्जेक्ट को ठीक से काम करने के लिए, आपको रुकावट से फ्रीआरटीओएस कार्यों के साथ काम करने के लिए स्वीकार्य सीमा में यूएआर रुकावट को प्राथमिकता देने की आवश्यकता है। अन्यथा, आप दिलचस्प हार्ड-टू-डीबग त्रुटियां प्राप्त कर सकते हैं। वर्तमान उदाहरण में, इंटरप्ट के लिए निम्न विकल्प FreeRTOSConfig.h फ़ाइल में सेट किए गए हैं।

FreeRTOSConfig.h में सेटिंग्स

 #define configPRIO_BITS 4 #define configKERNEL_INTERRUPT_PRIORITY 0XF0 //   FreeRTOS API   //   0x8 - 0xF. #define configMAX_SYSCALL_INTERRUPT_PRIORITY 0x80

प्रोजेक्ट में ही, क्लास nvic का एक ऑब्जेक्ट 0x9 को बाधित करने की प्राथमिकता निर्धारित करता है, जो कि मान्य श्रेणी में शामिल है (वर्ग nvic यहाँ और यहाँ वर्णित है )।

एक लुआ मशीन के लिए स्ट्रिंग गठन

Uart_terminal ऑब्जेक्ट से प्राप्त बाइट्स को एक साधारण वर्ग serial_cli के उदाहरण में स्थानांतरित किया जाता है, जो स्ट्रिंग को संपादित करने और इसे सीधे उस थ्रेड को पास करने के लिए प्रदान करता है जिसमें लुआ-मशीन निष्पादित होती है (कॉलबैक फ़ंक्शन को कॉल करके)। चरित्र 'r' को स्वीकार करने पर, कॉलबैक फ़ंक्शन कहा जाता है। इस फ़ंक्शन को स्वयं और "रिलीज़" नियंत्रण के लिए एक पंक्ति की प्रतिलिपि बनाना चाहिए (चूंकि कॉल के दौरान नई बाइट्स का स्वागत अवरुद्ध है। यह सही ढंग से प्राथमिकता वाली धाराओं और पर्याप्त रूप से कम यूएआर गति के साथ कोई समस्या नहीं है)।

सूत्रों का लिंक:

serial_cli विवरण फ़ाइलें यहाँ और यहाँ ;
यहां प्रोजेक्ट के हिस्से के रूप में एक क्लास ऑब्जेक्ट बनाना।

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

लुआ दुभाषिया और इसके निष्पादन के लिए एक स्ट्रिंग पास करना

लुआ दुभाषिया खुद नहीं जानता कि कैसे ब्लॉक कोड लाइन को लाइन से स्वीकार करना है, और फिर पूरे ब्लॉक को अपने दम पर निष्पादित करना है। हालाँकि, यदि आप कंप्यूटर पर Lua स्थापित करते हैं और इंटरप्रेटर को इंटरएक्टिव मोड में चलाते हैं, तो हम देख सकते हैं कि निष्पादन लाइन-बाय-लाइन है, जो आपके द्वारा लिखे जाने के अनुरूप है, और ब्लॉक अभी पूरा नहीं हुआ है। चूंकि इंटरैक्टिव मोड वह है जो मानक पैकेज में प्रदान किया गया है, हम इसका कोड देख सकते हैं। यह lua.c फ़ाइल में स्थित है। हम doREPL फ़ंक्शन और इसके द्वारा उपयोग की जाने वाली सभी चीज़ों में रुचि रखते हैं। साइकिल के साथ नहीं आने के लिए, परियोजना में इंटरेक्टिव मोड फ़ंक्शन प्राप्त करने के लिए, मैंने इस कोड का एक अलग वर्ग में एक पोर्ट बनाया, जिसे मैंने मूल फ़ंक्शन के नाम से lua_repl नाम दिया, जो कंसोल को जानकारी प्रिंट करने के लिए प्रिंटफ़ का उपयोग करता है और एक सार्वजनिक विधि add_lua_string करता है जो क्लास ऑब्जेक्ट से प्राप्त लाइन जोड़ने के लिए है। serial_cli ऊपर वर्णित है।

संदर्भ:

वर्ग विवरण lua_repl यहाँ ;
यहाँ , यहाँ और यहाँ कोड;

वर्ग सिंगलटन मायर्स पैटर्न के अनुसार बनाया गया है, क्योंकि एक ही डिवाइस के भीतर कई इंटरैक्टिव मोड देने की आवश्यकता नहीं है। क्लास lua_repl का एक ऑब्जेक्ट क्लास serial_cli के ऑब्जेक्ट से डेटा प्राप्त करता है ।

चूंकि परियोजना में पहले से ही वैश्विक वस्तुओं को शुरू करने और सर्विस करने के लिए एक एकीकृत प्रणाली है, इसलिए क्लास lua_repl के ऑब्जेक्ट के लिए सूचक को वैश्विक वर्ग खिलाड़ी :: बेस के ऑब्जेक्ट के लिए पास किया जाता है । क्लास प्लेयर :: बेस ( यहाँ घोषित किया गया है । इसे मुख्य वहाँ से भी कहा जाता है) के ऑब्जेक्ट के स्टार्ट मेथड में, क्लास lua_repl के ऑब्जेक्ट के इनिट मेथड को टास्क प्राथमिकता के साथ कहा जाता है FreeRTOS 3 (प्रोजेक्ट में, आप 1 से 4. के लिए एक टास्क प्राथमिकता दे सकते हैं सबसे कम प्राथमिकता है, और 4 उच्चतम है)। सफल आरंभीकरण के बाद, वैश्विक वर्ग फ्रीआरटीओएस अनुसूचक शुरू करता है और इंटरैक्टिव मोड अपना काम शुरू करता है।

पोर्टिंग समस्याएँ

नीचे उन समस्याओं की एक सूची दी गई है जो मुझे मशीन के लुआ पोर्ट के दौरान हुई थी।

वैरिएबल असाइनमेंट की 2-3 सिंगल-लाइन स्क्रिप्ट निष्पादित की जाती हैं, फिर सब कुछ कठिन गलती में गिर जाता है

समस्या वास्तविक पद्धति के साथ थी। यह न केवल ब्लॉक को फिर से चुनने के लिए आवश्यक है, बल्कि पुराने वाले की सामग्री को कॉपी करने के लिए भी है (जैसा कि ऊपर वर्णित है)।

जब एक मूल्य को प्रिंट करने की कोशिश करते हैं, तो दुभाषिया कठोर गलती में गिर जाता है

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

गैर-वाष्पशील (फ्लैश) मेमोरी के लिए आवश्यकताएँ

यहाँ कुछ माप दिए गए हैं, जिनसे मैंने निर्णय लिया कि लुआ मशीन को परियोजना में एकीकृत करने के लिए कितनी गैर-वाष्पशील (फ्लैश) मेमोरी को आवंटित करने की आवश्यकता है। संकलना gcc-arm-none-eabi-8-2018-q4-major का उपयोग करके किया गया था। Lua 5.4 के संस्करण का उपयोग किया गया था। नीचे दिए गए मापों में, "लुआ के बिना" वाक्यांश का अर्थ है, दुभाषिया के गैर-समावेश और इसके पुस्तकालयों और इसके पुस्तकालयों के साथ-साथ परियोजना में lua_repl वर्ग की एक वस्तु। सभी निम्न-स्तरीय इकाइयाँ ( प्रिंटफ़ और राइटराइट फ़ंक्शंस के लिए ओवरराइड सहित) परियोजना में बनी हुई हैं। FreeRTOS ढेर का आकार 1024 * 25 बाइट्स है। शेष पर वैश्विक परियोजना संस्थाओं का कब्जा है।

परिणामों की सारांश तालिका निम्नानुसार है (बाइट में सभी आकार):

विकल्प बनाएँ	बिना लुआ	केवल कोर	बेस लाइब्रेरी वाला लुआ	लाइब्रेरी बेस, कोरटाइन, टेबल, स्ट्रिंग के साथ लुआ	luaL_openlibs
-ओ०-जी ३	103,028	220,924	236,124	262,652	308,372
-ओ १-जी ३	74940	144,732	156,916	174,452	213,068
—ओ ० —ग ०	71,172	134,228	145,756	161,428	198,400

रैम आवश्यकताओं

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

संरचना	रैम का इस्तेमाल किया
बेस लाइब्रेरी वाला लुआ	4809
लाइब्रेरी बेस, कोरटाइन, टेबल, स्ट्रिंग के साथ लुआ	6407
luaL_openlibs	12,769

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

इसके अलावा, टास्क स्टैक को 4 केबी भी आवंटित किया जाता है, जिसमें लुआ-मशीन निष्पादित होता है।

आगे उपयोग करें

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

परिणाम

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

हम माइक्रोकंट्रोलर (stm32) के लिए प्रोजेक्ट में Lua दुभाषिया को एम्बेड करते हैं