आर्म मीड ओएस का अनुप्रयोग। ठीक ट्यूनिंग

आर्म मीड ओएस का उपयोग करने के बाद , एलईडी को ब्लिंक करना संभव था, यह अन्य महत्वपूर्ण सेवाओं का परीक्षण और कॉन्फ़िगर करने का समय था। निम्नलिखित वर्णित है:

• Mbed विन्यास प्रौद्योगिकी
• नियमित RTOS में C ++ पर स्विच करना क्यों मुश्किल है
• RTOS में मेमोरी कैसे सेव करें
• Mbed OS में इंटरप्ट कैसे आयोजित किया जाता है
• Mbed OS को डीबग करना सुविधाजनक है
• एसडीके अमूर्तता की एक अतिरिक्त परत से कैसे छुटकारा पाएं

हम एआरएम मीड ओएस का उपयोग करके एमकेई 18 एफ परिवार के प्रोग्रामिंग माइक्रोकंट्रोलर की तकनीक के साथ अपने परिचित को जारी रखते हैं

• पहला लेख

Mbed विन्यास प्रौद्योगिकी

Mbed परियोजना का एक महत्वपूर्ण घटक एक स्वचालित कॉन्फ़िगरेशन और असेंबली प्रणाली है, दोनों ऑनलाइन और ऑफलाइन , अर्थात्। उपयोगकर्ता के कंप्यूटर पर स्थानीय रूप से। यह विशेष नाम के साथ .json फ़ाइलों को संपादित करके कॉन्फ़िगर करने का प्रस्ताव है। फिर, पायथन प्रोजेक्ट की स्क्रिप्ट्स इन फाइलों को हेडर फाइल्स, यूजर-सेलेक्टेड IDE के वर्कस्पेस फाइल्स, लिंकर कमांड फाइल्स और अन्य सपोर्टिंग फाइल्स में बदल देती हैं।

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

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

• आईडीई संकलक विकल्प
• लिंकर MKE18F512xxx16_flash.icf बैच फ़ाइल
• हैडर फ़ाइल mbed_config.h

Mbed_config.h फ़ाइल में, आप लगभग 130 परिभाषित कर सकते हैं, जो पहली बार में बहुत कष्टप्रद है। लेकिन सौभाग्य से, उनमें से ज्यादातर वायरलेस प्रोटोकॉल के ढेर से संबंधित हैं जो वर्तमान में परियोजना में उपयोग नहीं किए जाते हैं। सुविधा के लिए, प्रविष्टियों को क्रमबद्ध किया गया था ताकि वास्तविक लोगों को शीर्ष पर रखा जाए। प्रारंभ में, mbed_config.h फ़ाइल में अलग-अलग मॉड्यूल के लिए परिभाषित बेतरतीब ढंग से स्थित हैं , लेकिन छंटाई के बाद यह इस तरह दिखता है:

#ifndef __MBED_CONFIG_DATA__ #define __MBED_CONFIG_DATA__ // Configuration parameters #define MBED_CONF_RTOS_PRESENT 1 // set by library:rtos #define MBED_ALL_STATS_ENABLED 1 //#define DEVICE_SLEEP=1       SLEEP      #define MBED_CONF_APP_MAIN_STACK_SIZE 1024 #define MBED_CONF_APP_TIMER_THREAD_STACK_SIZE 512 #define MBED_CONF_APP_IDLE_THREAD_STACK_SIZE 512 #define MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE 3000000 // set by library:platform #define MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO 0 // set by library:platform #define MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 0 // set by library:platform #define MBED_CONF_PLATFORM_ERROR_HIST_ENABLED 0 // set by library:platform #define MBED_CONF_PLATFORM_ERROR_HIST_SIZE 4 // set by library:platform #define MBED_CONF_PLATFORM_FORCE_NON_COPYABLE_ERROR 0 // set by library:platform #define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16 // set by library:platform #define MBED_CONF_PLATFORM_POLL_USE_LOWPOWER_TIMER 0 // set by library:platform #define MBED_CONF_PLATFORM_STDIO_BAUD_RATE 3000000 // set by library:platform #define MBED_CONF_PLATFORM_STDIO_BUFFERED_SERIAL 0 // set by library:platform #define MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES 1 // set by library:platform #define MBED_CONF_PLATFORM_STDIO_CONVERT_TTY_NEWLINES 0 // set by library:platform #define MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT 1 // set by library:platform #define MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE 256 // set by library:drivers #define MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE 256 // set by library:drivers #define MBED_CONF_EVENTS_PRESENT 1 // set by library:events #define MBED_CONF_EVENTS_SHARED_DISPATCH_FROM_APPLICATION 0 // set by library:events #define MBED_CONF_EVENTS_SHARED_EVENTSIZE 256 // set by library:events #define MBED_CONF_EVENTS_SHARED_HIGHPRIO_EVENTSIZE 256 // set by library:events #define MBED_CONF_EVENTS_SHARED_HIGHPRIO_STACKSIZE 1024 // set by library:events #define MBED_CONF_EVENTS_SHARED_STACKSIZE 1024 // set by library:events #define MBED_CONF_EVENTS_USE_LOWPOWER_TIMER_TICKER 0 // set by library:events #define MBED_CONF_CELLULAR_DEBUG_AT 0 // set by library:cellular #define MBED_CONF_CELLULAR_RANDOM_MAX_START_DELAY 0 // set by library:cellular #define MBED_CONF_CELLULAR_USE_APN_LOOKUP 1 // set by library:cellular #define MBED_CONF_FILESYSTEM_PRESENT 1 // set by library:filesystem #define MBED_CONF_KINETIS_EMAC_RX_RING_LEN 16 // set by library:kinetis-emac #define MBED_CONF_KINETIS_EMAC_TX_RING_LEN 8 // set by library:kinetis-emac #define MBED_CONF_LORA_ADR_ON 1 // set by library:lora #define MBED_CONF_LORA_APP_PORT 15 // set by library:lora #define MBED_CONF_LORA_APPLICATION_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora #define MBED_CONF_LORA_APPLICATION_KEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora #define MBED_CONF_LORA_APPSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora #define MBED_CONF_LORA_AUTOMATIC_UPLINK_MESSAGE 1 // set by library:lora #define MBED_CONF_LORA_DEVICE_ADDRESS 0x00000000 // set by library:lora #define MBED_CONF_LORA_DEVICE_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora #define MBED_CONF_LORA_DUTY_CYCLE_ON 1 // set by library:lora #define MBED_CONF_LORA_LBT_ON 0 // set by library:lora #define MBED_CONF_LORA_NB_TRIALS 12 // set by library:lora #define MBED_CONF_LORA_NWKSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora #define MBED_CONF_LORA_OVER_THE_AIR_ACTIVATION 1 // set by library:lora #define MBED_CONF_LORA_PHY EU868 // set by library:lora #define MBED_CONF_LORA_PUBLIC_NETWORK 1 // set by library:lora #define MBED_CONF_LORA_TX_MAX_SIZE 64 // set by library:lora #define MBED_CONF_LWIP_ADDR_TIMEOUT 5 // set by library:lwip #define MBED_CONF_LWIP_ADDR_TIMEOUT_MODE 1 // set by library:lwip #define MBED_CONF_LWIP_DEBUG_ENABLED 0 // set by library:lwip #define MBED_CONF_LWIP_DEFAULT_THREAD_STACKSIZE 512 // set by library:lwip #define MBED_CONF_LWIP_ENABLE_PPP_TRACE 0 // set by library:lwip #define MBED_CONF_LWIP_ETHERNET_ENABLED 1 // set by library:lwip #define MBED_CONF_LWIP_IP_VER_PREF 4 // set by library:lwip #define MBED_CONF_LWIP_IPV4_ENABLED 1 // set by library:lwip #define MBED_CONF_LWIP_IPV6_ENABLED 0 // set by library:lwip #define MBED_CONF_LWIP_MEM_SIZE 36560 // set by library:lwip[Freescale] #define MBED_CONF_LWIP_PPP_THREAD_STACKSIZE 768 // set by library:lwip #define MBED_CONF_LWIP_SOCKET_MAX 4 // set by library:lwip #define MBED_CONF_LWIP_TCP_ENABLED 1 // set by library:lwip #define MBED_CONF_LWIP_TCP_SERVER_MAX 4 // set by library:lwip #define MBED_CONF_LWIP_TCP_SOCKET_MAX 4 // set by library:lwip #define MBED_CONF_LWIP_TCPIP_THREAD_STACKSIZE 1200 // set by library:lwip #define MBED_CONF_LWIP_UDP_SOCKET_MAX 4 // set by library:lwip #define MBED_CONF_LWIP_USE_MBED_TRACE 0 // set by library:lwip #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL 0 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_PAGE 0 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_DEVICE_TYPE NET_6LOWPAN_ROUTER // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER 0xffff // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf} // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY_ID 1 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SEC_LEVEL 5 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SECURITY_MODE NONE // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_HEAP_SIZE 32500 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL 22 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE 0 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_COMMISSIONING_DATASET_TIMESTAMP 0x10000 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_EXTENDED_PANID {0xf1, 0xb5, 0xa1, 0xb2,0xc4, 0xd5, 0xa1, 0xbd } // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_ML_PREFIX {0xfd, 0x0, 0x0d, 0xb8, 0x0, 0x0, 0x0, 0x0} // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME "Thread Network" // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PANID 0x0700 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PSKC {0xc8, 0xa6, 0x2e, 0xae, 0xf3, 0x68, 0xf3, 0x46, 0xa9, 0x9e, 0x57, 0x85, 0x98, 0x9d, 0x1c, 0xd0} // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE MESH_DEVICE_TYPE_THREAD_ROUTER // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_MASTER_KEY {0x10, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff} // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_PSKD "ABCDEFGH" // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_SECURITY_POLICY 255 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_THREAD_USE_STATIC_LINK_CONFIG 1 // set by library:mbed-mesh-api #define MBED_CONF_MBED_MESH_API_USE_MALLOC_FOR_HEAP 0 // set by library:mbed-mesh-api #define MBED_CONF_NANOSTACK_CONFIGURATION nanostack_full // set by library:nanostack #define MBED_CONF_NANOSTACK_HAL_CRITICAL_SECTION_USABLE_FROM_INTERRUPT 0 // set by library:nanostack-hal #define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_DISPATCH_FROM_APPLICATION 0 // set by library:nanostack-hal #define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE 6144 // set by library:nanostack-hal #define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_USE_MBED_EVENTS 0 // set by library:nanostack-hal #define MBED_CONF_NANOSTACK_HAL_NVM_CFSTORE 0 // set by library:nanostack-hal #define MBED_CONF_NSAPI_DEFAULT_MESH_TYPE THREAD // set by library:nsapi #define MBED_CONF_NSAPI_DEFAULT_STACK LWIP // set by library:nsapi #define MBED_CONF_NSAPI_DEFAULT_WIFI_SECURITY NONE // set by library:nsapi #define MBED_CONF_NSAPI_DNS_CACHE_SIZE 3 // set by library:nsapi #define MBED_CONF_NSAPI_DNS_RESPONSE_WAIT_TIME 5000 // set by library:nsapi #define MBED_CONF_NSAPI_DNS_RETRIES 0 // set by library:nsapi #define MBED_CONF_NSAPI_DNS_TOTAL_ATTEMPTS 3 // set by library:nsapi #define MBED_CONF_NSAPI_PRESENT 1 // set by library:nsapi #define MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP 1 // set by library:ppp-cell-iface #define MBED_CONF_PPP_CELL_IFACE_AT_PARSER_BUFFER_SIZE 256 // set by library:ppp-cell-iface #define MBED_CONF_PPP_CELL_IFACE_AT_PARSER_TIMEOUT 8000 // set by library:ppp-cell-iface #define MBED_CONF_PPP_CELL_IFACE_BAUD_RATE 115200 // set by library:ppp-cell-iface #define MBED_CONF_TARGET_NETWORK_DEFAULT_INTERFACE_TYPE ETHERNET // set by target:K66F #define MBED_LFS_BLOCK_SIZE 512 // set by library:littlefs #define MBED_LFS_ENABLE_INFO 0 // set by library:littlefs #define MBED_LFS_INTRINSICS 1 // set by library:littlefs #define MBED_LFS_LOOKAHEAD 512 // set by library:littlefs #define MBED_LFS_PROG_SIZE 64 // set by library:littlefs #define MBED_LFS_READ_SIZE 64 // set by library:littlefs #define NSAPI_PPP_AVAILABLE 0 // set by library:lwip #define NSAPI_PPP_IPV4_AVAILABLE 1 // set by library:lwip #define NSAPI_PPP_IPV6_AVAILABLE 0 // set by library:lwip #define NVSTORE_ENABLED 1 // set by library:nvstore #define NVSTORE_MAX_KEYS 16 // set by library:nvstore // Macros #define _RTE_ // defined by library:rtos #define NS_USE_EXTERNAL_MBED_TLS // defined by library:nanostack #define UNITY_INCLUDE_CONFIG_H // defined by library:utest #endif 

आरटीओएस पर लागू सी ++ के लिए संक्रमण की विशेषताएं

Mbed में शीर्ष-स्तरीय API C ++ में लिखा गया है , इसलिए इस भाषा का उपयोग अनुप्रयोग कोड में किया जाना है। लेकिन ऐसी बारीकियां हैं जिनके बारे में आपको जानना आवश्यक है।
छोटे एम्बेडेड सिस्टम पर RTOS के लिए C ++ का उपयोग करना अभी भी अपेक्षाकृत दुर्लभ है। यहाँ समस्या यह है कि सफल RTOS परियोजनाएँ बहु-प्लेटफ़ॉर्म होने का प्रयास करती हैं, जबकि C ++ , C की तुलना में प्लेटफ़ॉर्म रिसोर्स मैनेजमेंट पर उच्च मांग रखती है । इसका कारण उपयोगकर्ता से निम्न-स्तरीय संसाधन प्रबंधन के विवरण को छिपाने की इच्छा है। यह मुख्य रूप से स्मृति संसाधनों के बारे में है। कंस्ट्रक्टर्स, डिस्ट्रक्टर्स, थ्रेड्स, स्वचालित विनाश के साथ अपवाद, डेटा संरचना वस्तुओं के टेम्पलेट आदि, गतिशील मेमोरी के साथ निहित संचालन का उपयोग करते हैं। लेकिन छोटे सिस्टम में रैम का संसाधन बहुत सीमित है। ऐसी प्रणालियों में और विशेषकर आरटीओएस में रैम सबसे दुर्लभ संसाधन है। RTOS में, प्रत्येक कार्य को एक स्टैक आवंटित किया जाता है, डेवलपर इसके सटीक आकार का पहले से अनुमान नहीं लगा सकता है और इसलिए एक मार्जिन के साथ चुनता है। इस प्रकार, एक दर्जन कार्यों के साथ आरटीओएस की उपस्थिति तुरंत 10 से 30 केबी के रैम आकार की आवश्यकता होती है। विभिन्न पार्सर और प्रोटोकॉल (HTTP, HTML ...) और फ़ाइल सिस्टम के लिए बहुत सारी मेमोरी की आवश्यकता होती है। यदि किसी डिस्प्ले का उपयोग किया जाता है, तो मुफ्त रैम की आवश्यकताएं और बढ़ जाती हैं।

IAR जैसे विकास वातावरण के पुस्तकालय अच्छे गतिशील मेमोरी प्रबंधकों से सुसज्जित हैं, लेकिन वे एकल-थ्रेडेड रनटाइम वातावरण के लिए डिज़ाइन किए गए हैं। उनके लिए आरटीओएस में काम करना शुरू करने के लिए , आपको अतिरिक्त कोड लिखने की आवश्यकता है। इस प्रक्रिया को रिटारगेटिंग कहा जाता है।
C में लिखे गए RTOS में , आमतौर पर रिटारगेटिंग नहीं किया जाता है। चूंकि भाषा के स्तर पर गतिशील मेमोरी के साथ कोई अंतर्निहित संचालन नहीं है, इसलिए सभी ऑपरेशनों को स्पष्ट रूप से अपने स्वयं के थ्रेड-सुरक्षित संस्करणों को मल्कोक और मुक्त कार्यों को कॉल करके किया जाता है। प्रोग्रामर का गतिशील मेमोरी के साथ संचालन पर पूर्ण नियंत्रण है और इसे बचाने के लिए सभी संभव उपाय आसानी से लागू कर सकते हैं।

C ++ के मामले में , यदि हम इस भाषा की सभी विशेषताओं का उपयोग करना चाहते हैं , तो हमें रिटारगेटिंग करना होगा। लेकिन प्रत्येक विकास के माहौल में पुनरावृत्ति एक विशुद्ध रूप से व्यक्तिगत प्रक्रिया है। यह RTOS डेवलपर्स के लिए जीवन को कठिन बनाता है।

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

Mbed कुछ में से एक है यदि केवल RTOS ही नहीं है, जो पहले से ही किए गए विकास साधनों की एक श्रृंखला के लिए रिटारगेटिंग के साथ स्रोत कोड प्रदान करता है: GCC , IAR , Keil
उपरोक्त सभी के बावजूद, आप रिटारगेटिंग किए बिना आरटीओएस को सी ++ में पोर्ट करने पर लेख पा सकते हैं, उदाहरण के लिए, बस अपने स्वयं के साथ कुछ सामान्य मानक कार्यों को बदलकर समस्या को हल करना। यह काम कर सकता है, लेकिन तब प्रोग्रामर को I + में C ++ कंस्ट्रक्शन (केवल स्टैटिक कंस्ट्रक्टर, नए के लिए सभी पैटर्न की जांच करना, अपवादों को छोड़ना इत्यादि) का उपयोग करते समय विभिन्न निहित और अनैच्छिक प्रतिबंधों के बारे में पता होना चाहिए। C ++ को कॉल करना पहले से ही मुश्किल होगा। Mbed, एक उपयोगकर्ता के अनुकूल प्रणाली के रूप में, सरलता में Arduino के पास, इन सीमाओं को हटाता है।

IAR के सभी हाल के संस्करणों के अलावा, C11 और C ++ 14 पर स्विच करने में कठिनाइयाँ हैं, जैसा कि यहाँ वर्णित है - https://www.iar.com/support/resources/articles/exploring-c11-and-c14/

Mbed में व्यवधान कैसे आयोजित किए जाते हैं

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

ऐसे सवालों के जवाब CMSIS Cortex-M4 कोर पेरिफेरल एक्सेस लेयर CMSIS-RTOS में मांगे जाने चाहिए। मैक्रोज़ को वहां परिभाषित किया गया है:

• NVIC_SetVector - किसी दिए गए वेक्टर के लिए बाधा सेवा दिनचर्या (ISR) निर्धारित करता है
• NVIC_SetPriority - निर्दिष्ट व्यवधान वेक्टर के लिए प्राथमिकता निर्धारित करता है।
• NVIC_EnableIRQ - दिए गए वेक्टर पर कॉल को बाधित करने की अनुमति देता है

यहां बताया गया है कि SysTick टाइमर से इंटरप्ट संगठन कैसे आरंभ किया जाता है:

  NVIC_SetVector(mbed_get_m0_tick_irqn(), (uint32_t)SysTick_Handler); //   mbed_get_m0_tick_irqn       SysTick. //        SysTick_IRQn    MKE18F16.h //  SysTick_Handler   . NVIC_SetPriority(mbed_get_m0_tick_irqn(), 0xFF); // 0xFF    .      .   NVIC    MKE18F16   16  . ..   4-  . NVIC_EnableIRQ(mbed_get_m0_tick_irqn()); //    . 

कार्य की प्राथमिकताएं और बाधित प्राथमिकताएं भ्रमित नहीं होनी चाहिए।

यदि प्राथमिकता नहीं दी गई है, तो डिफ़ॉल्ट रूप से इसे अधिकतम पर सेट किया जाता है।
इस तरह से सौंपे गए बाधा हैंडलर से, आप किसी भी आरटीओएस सेवाओं को कॉल कर सकते हैं जो उम्मीदों का कारण नहीं बनती हैं। यानी झंडे, अर्ध-संदेश, संदेश, मेलबॉक्‍सेज़ आदि संचारित करें हालाँकि, सेवाओं को ISR से नहीं, बल्कि कॉल किया जाता है, जो कॉर्टेक्स-एम कर्नेल के सिस्टम कंट्रोल ब्लॉक ( SCB ) के इंटरप्ट कंट्रोल और स्टेट रजिस्टर ( ICSR) में PENDSVSET बिट सेट करके सॉफ्टवेयर को बाधित करता है। यानी वर्तमान रुकावट हैंडलर के पूरा होने के बाद, अगर कोई अन्य प्राथमिकताएं बाधित नहीं होती हैं, तो सिस्टम हैंडलर को PendSV वेक्टर द्वारा बुलाया जाएगा जहां सेवा निष्पादित की जाएगी।

Mbed गतिशील मेमोरी के साथ कैसे काम करती है?

C ++ में प्रोग्रामिंग करते समय डायनामिक मेमोरी, या फिर ढेर या हीप, एक आवश्यक घटक है । IAR के तहत हमारी Mbed परियोजना में, इस मेमोरी क्षेत्र का आकार MKE18F512xxx16_flash.icf लिंकर की सेटिंग फ़ाइल में __size_heap__ चर पर लिखकर निर्धारित किया जाता है। हम आकार सेट करते हैं ताकि यह सभी शेष मुक्त मेमोरी को ले जाए। हम जानते हैं कि संकलन के बाद .map फ़ाइल से कितनी मुफ्त मेमोरी बची है, आकार का ढेर एक पुनरावृत्ति प्रक्रिया है।

C ++ ऑब्जेक्ट के स्थिर कंस्ट्रक्टर को कॉल करना

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

Mbed ने इस मुद्दे को अधिक गंभीरता से लिया। प्रत्येक विकास के लिए पर्यावरण का अपना दृष्टिकोण होता है। IAR में, यह इस तरह किया जाता है:

• डिज़ाइनर्स कॉल से पहले भी उपयोगकर्ता कोड द्वारा इनिशियलाइज़ेशन स्ट्रीम को इंटरसेप्ट किया गया है
• आरटीओएस एपीआई से प्रवाह को अवरुद्ध करने के तरीकों को मानक पुस्तकालय में प्रतिस्थापित किया जाता है
• मानक कार्य नए , हटाएं , हटाएं , मुक्त करें ... आरटीओएस डायनेमिक मेमोरी एपीआई पर कॉल करने के लिए पुनर्निर्देशित किए गए हैं।

Mbed बहु-थ्रेडेड ऑपरेशन के लिए IAR लाइब्रेरी एडेप्टर का उपयोग करता है
आप यहाँ मल्टीथ्रेडिंग के लिए IAR को अपनाने के बारे में पढ़ सकते हैं - http://supp.iar.com/FilesPublic/UPDINFO/005691/arm/doc/infocenter/DLIBThreadSupport.html
Mbed ने IAR लाइब्रेरी के सिस्टम लॉक और फाइल स्ट्रीम लॉक दोनों को अनुकूलित किया है। वे mbed_boot.c फ़ाइल में कार्यान्वित किए जाते हैं और OS म्यूटेक्स का उपयोग करते हैं ।

स्टार्टअप_MKE18F16.s फ़ाइल की बहुत पहली पंक्तियों में निष्पादित __i__program_start फ़ंक्शन OS को स्टैक और डायनामिक मेमोरी को mbed_set_stack_heap कहकर आरंभ करता है

आकार देने कार्य ढेर

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

स्टार्टअप पर Mbed OS तुरंत नामों के साथ तीन कार्य बनाता है: "main_thread" , "टाइमर_थ्रेड" , "idle_thread" । उनके लिए डिफ़ॉल्ट स्टैक का आकार मैक्रोज़ द्वारा हेडर फ़ाइल mbed_rtx_conf.h में निर्धारित किया गया था। हमने इन ढेर की घोषणाओं को mbed_config.h कॉन्फ़िगरेशन फ़ाइल में स्थानांतरित कर दिया और ढेर का आकार कम कर दिया। अब परिभाषाएँ इस तरह दिखती हैं:

• "Main_thread" कार्य स्टैक को मैक्रो MBED_CONF_APP_MAIN_STACK_SIZE = 1024 बाइट द्वारा परिभाषित किया गया है
• टाइमर_thread कार्य स्टैक मैक्रो MBED_CONF_APP_TIMER_THREAD_STACK_SIZE = 512 बाइट्स द्वारा परिभाषित किया गया है
• Idle_thread task stack मैक्रो MBED_CONF_APP_IDLE_THREAD_STACK_SIZE = 512 बाइट्स द्वारा परिभाषित किया गया है

मेमोरी मेमोरी कंट्रोल नियंत्रित करता है

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

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

कोड कोड डिबगिंग और विश्लेषण उपकरण

नए प्लेटफॉर्म पर मेबड के काम का वास्तव में गहराई से अध्ययन केवल जेटीजी / एसडब्ल्यूडी डीबगर का उपयोग करके संभव है।

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

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

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

यह बचत के लायक नहीं है, विकास का 90% समय डिबगिंग पर खर्च किया जाता है। हालांकि अधिक महंगा सेगर जे-ट्रेस ट्रेसर अब एक बड़ा लाभ प्रदान नहीं करते हैं, क्योंकि MKE18F श्रृंखला में एक विशेष ट्रेसर इंटरफ़ेस नहीं है।

दूसरा डिबगिंग टूल, निश्चित रूप से, I / O UART के माध्यम से है। UART के माध्यम से सीरियल डेटा चैनल तक पहुँचने के लिए Mbed में कम से कम चार अलग-अलग प्रौद्योगिकियाँ हैं।

यह है:

• मानक C / C ++ I / O फ़ंक्शन के DirectSerial वर्ग के माध्यम से पुनर्निर्देशन
• कक्षा RawSerial
• वर्ग धारावाहिक
• कक्षा UARTSerial

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

Mbed को पोर्ट करके हम कितने टाइमर खो देते हैं

एलईडी को ब्लिंक करने के लिए, एमएड ओएस एपीआई से प्रतीक्षा फ़ंक्शन का उपयोग किया गया था । पिछले लेख में इसे पोर्ट करने की समस्याओं के बारे में बात की गई थी। लेकिन यह सब नहीं है, सिवाय Mbed अपने काम का एक काउंटर रखता है (इसे mbed_stats_cpu_get फ़ंक्शन द्वारा पढ़ा जा सकता है) और एक टाइमर एपीआई है । ये सेवाएँ lp_ticker.c फ़ाइल से निम्न-स्तरीय फ़ंक्शन का उपयोग करती हैं। इस फ़ाइल में, काइनेटिस परिधीय किट से LPTMR टाइमर का उपयोग समय गणना को व्यवस्थित करने के लिए किया जाता है। पोर्टिंग प्रक्रिया के दौरान, इस फ़ाइल को MKE18F512VLL16 माइक्रोकंट्रोलर में उपयोग की जाने वाली क्लॉकिंग विधियों से मिलान करने के लिए संपादित किया गया था।

इस प्रकार, Mbed पोर्ट पूरी तरह से दो काउंटर मॉड्यूल - PIT और LPTMR और SysTick कोर टाइमर को कैप्चर करता है । एक लागू कार्य के लिए संसाधनों की योजना बनाते समय यह याद रखना चाहिए।

MKE18F बूटस्ट्रैप सुविधाएँ

चिप्स के MKE18F परिवार में सीरियल इंटरफेस के माध्यम से बूटलोडर के साथ एक अंतर्निहित ROM है: UART, CAN, SPI, I2C । लेकिन हमारे बोर्ड पर हमारे सुरक्षित बूटलोडर का उपयोग करने की योजना है, इसलिए एक नियमित बूटलोडर का काम अवांछनीय है।
इस मामले में, कैनेटीस चिप्स को 0x040D पर प्रोग्राम फ्लैश क्षेत्र की सामग्री पर ध्यान देने की आवश्यकता है । एक स्थिरांक संग्रहीत है जो बूट क्रम को निर्धारित करता है। हमारे मामले में, निरंतर 0x7B को वहां लिखा जाना चाहिए, जो फ्लैश मेमोरी से शुरुआत का संकेत देता है, न कि रोम से और बाहरी आउटपुट पर एनएमआई फ़ंक्शन को अक्षम करने से। इस स्थिरांक के लिए एक अलग मान के साथ, प्रोग्राम अंतर्निहित बूटलोडर में गलती से ROM से फ्रीज हो सकता है।

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

वॉचडॉग सक्रिय करें

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

प्रारंभ में, system_MKE18F16.h फ़ाइल में DISABLE_WDOG मैक्रो को वॉचडॉग को अक्षम करने के लिए सेट किया गया था। स्थिति को ठीक करने के लिए, इस मैक्रो को मिटा दिया गया और डब्ल्यूडीओजी के अपने स्वयं के प्रारंभ को लागू किया गया ।

वॉचडॉग का आरंभीकरण SystemInit फ़ंक्शन में किया गया है। वॉचडॉग काउंटर को IDLE कार्य में अपडेट किया गया है।

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

ड्राइवर एसडीके डिलीवरी से जारी करते हैं

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

ड्राइवरों को परिवार के सभी चिप्स पर काम करने के लिए डिज़ाइन किया गया है अर्थात्। सार्वभौमिक हो और इसलिए सशर्त मैक्रो के साथ संतृप्त होता है और जांचता है कि प्रत्येक विशेष चिप के लिए कोई उपयोगी कार्य नहीं करता है।

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

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

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

याद रखें कि MKE18F के लिए Mbed पोर्ट बिना प्राथमिकता के UART और टाइमर इंटरप्ट को आरंभ करता है, अर्थात। वे डिफ़ॉल्ट रूप से अधिकतम स्तर प्राप्त करते हैं।