Windows के अंतर्गत STM32CubeIDE में स्थानीय रूप से इकाई परीक्षण चलाएं

परिचय

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

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

एम्बेडेड प्लेटफार्मों के लिए यूनिट परीक्षण चलाने के तीन तरीके हैं:

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

यह प्रकाशन ग्रहण के आधार पर STM32CubeIDE वातावरण में इकाई परीक्षणों को कॉन्फ़िगर करने का एक तरीका प्रदान करता है, और STM32 परिवार के नियंत्रकों के लिए विकास का इरादा रखता है। विकास भाषा C है, लेकिन परीक्षण स्वयं C ++ में लिखे गए हैं। सिगविन का उपयोग करके विंडोज होस्ट मशीन पर टेस्ट चलेंगे। परीक्षण ढांचे के रूप में, Google टेस्ट का उपयोग किया जाता है। परिणाम इकाई परीक्षण के लिए एक विशेष प्लग-इन विंडो में प्रदर्शित किए जाएंगे, और उन्हें STM1 के लिए प्रोजेक्ट से एक बटन के साथ लॉन्च किया जा सकता है:

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

आपको आवश्यकता होगी

1. Cygwin 3.0.7 x86 (चूंकि परीक्षण 32-बिट माइक्रोकंट्रोलर के लिए हैं, हम 64-बिट प्लेटफॉर्म पर भी 32-बिट वातावरण का उपयोग करेंगे)
2. STM32CubeIDE विंडोज के लिए 1.0.2।
3. Google टेस्ट फ्रेमवर्क 1.8.1

Cygwin और STM32CubeIDE स्थापित करें

Cygwin

Cygwin, x86 संस्करण स्थापित करें। इंस्टॉलर में, अतिरिक्त पैकेज चुनें: gcc-core, g ++, binutils, automake, autoconf, cmake, libtool, gdb, make। आप संकुल के नवीनतम स्थिर संस्करण स्थापित कर सकते हैं।

आपको पर्यावरण चर भी पंजीकृत करने की आवश्यकता है:

पथ: ...; C: \ <path_to_Cygwin> \ Cygwin \ bin; C: \ <path_to_Cygwin> \ Cygwin \ lib
classpath: C: \ <path_to_Cygwin> \ Cygwin \ lib

STM32CubeIDE

पर्यावरण हमेशा की तरह स्थापित है। साइग्विन के बाद क्यूबिड को स्थापित करने की सलाह दी जाती है, क्योंकि इस मामले में क्यूब मौजूदा साइगविन टूलचिन को उठाएगा।

सबसे पहले, x86 Cygwin प्लेटफ़ॉर्म के लिए C ++ प्रोजेक्ट बनाएं। हमें टूलचिन की कार्यक्षमता की जांच करने के लिए सबसे पहले, इसकी आवश्यकता होगी, और दूसरी बात, हम इसे मुख्य परियोजना के लिए विधानसभा कॉन्फ़िगरेशन के "दाता" के रूप में उपयोग करेंगे।

फ़ाइल> नया> C / C ++ प्रोजेक्ट चुनें। C ++ प्रबंधित बिल्ड का चयन करें। हम Cygwin GCC टूलकिन के लिए टाइप हैलो दुनिया का एक प्रोजेक्ट बनाते हैं:

अगला, आपको यह चुनने की आवश्यकता होगी कि कौन से विधानसभा कॉन्फ़िगरेशन बनाने के लिए। बस डिबग ही काफी है।
अब आप सत्यापित कर सकते हैं कि प्रोजेक्ट> बिल्ड ऑल को चुनकर प्रोजेक्ट चल रहा है। यह भी सलाह दी जाती है कि रन> डिबग अस> लोकल सी / सी ++ एप्लिकेशन चलाकर सिगविन के तहत डिबगिंग की जांच करें। एप्लिकेशन "हैलो वर्ल्ड" को क्यूबाइड के अंदर कंसोल में आउटपुट करेगा।

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

• \ cygdrive \ c - C: \
• \ cygdrive \ g - G: \

एक सुंदर परीक्षण चलाने के लिए, हमें C ++ के लिए इकाई परीक्षणों के समर्थन के साथ ग्रहण के लिए प्लग-इन की भी आवश्यकता है। इसे सीधे STM32CubeIDE से इंस्टॉल किया गया है: मेनू हेल्प> न्यू सॉफ्टवेयर इंस्टॉल करें, फिर एक्लिप्स रिपॉजिटरी चुनें और C / C ++ यूनिट टेस्टिंग सपोर्ट प्लगइन इंस्टॉल करें।

Google टेस्ट लाइब्रेरी बनाएँ

पुस्तकालय का स्रोत कोड यहां पाया जा सकता है: https://github.com/google/googletest/tree/release-1.8.1
स्रोतों को अनपैक करें, सिओग्विन टर्मिनल का उपयोग करके googletest-release-1.8.1 निर्देशिका पर जाएं, और चलाएं:

cmake . make 

सफल असेंबली के बाद, स्थिर लाइब्रेरी फ़ाइल ./googlemock/lib/libgtest.a में होगी, और शीर्ष लेख फ़ाइलें ./googletest/include/gtest/ निर्देशिका में होंगी। उन्हें हमारी परियोजना में कॉपी करना होगा (या प्रोजेक्ट सेटिंग्स में इन फ़ाइलों के लिए पथ लिखना होगा)।

STM32 के लिए एक परियोजना बनाना

STM32L476G-DISCO डिबग बोर्ड के लिए डिज़ाइन। उदाहरण बहुत अधिक परिष्कृत नहीं होगा - बोर्ड पर दो एलईडी हैं, उन्हें 00 से 11. तक एक बाइनरी काउंटर दिखाते हैं। हम काउंटर के लिए एक अलग मॉड्यूल को लागू करेंगे, .h और .c फ़ाइलों की एक जोड़ी में वर्णित है, और इसके लिए एक परीक्षण लिखें।
क्यूब विन्यासक का उपयोग करके परियोजना को हमेशा की तरह बनाया जा सकता है, मुख्य बात यह सुनिश्चित करना है कि पीबी 2 और पीई 8 पिन डिजिटल आउटपुट के रूप में कॉन्फ़िगर किए गए हैं। प्रोजेक्ट बनाते समय, टाइप - C ++ निर्दिष्ट करना बेहतर होगा, परीक्षणों को संकलित करने के लिए यह आवश्यक होगा (मुख्य कोड अभी भी सी कंपाइलर द्वारा संकलित किया जाएगा)। सी से एक परियोजना को परिवर्तित करना बाद में संभव होगा, आरएमबी परियोजना के नाम पर क्लिक करके और "कन्वर्ट सी + +" का चयन करें।

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

हमारे काउंटर मॉड्यूल को सामान्य निर्देशिका में जोड़ें:

 #ifndef LED_COUNTER_H_ #define LED_COUNTER_H_ #include <stdint.h> void Led_Counter_Init(); uint8_t Led_Counter_Get_Next(); #endif /* LED_COUNTER_H_ */ 

 #include "led_counter.h" static uint8_t led_cnt_state = 0; void Led_Counter_Init() { led_cnt_state = 0; } uint8_t Led_Counter_Get_Next() { if(++led_cnt_state > 3) led_cnt_state = 0; return led_cnt_state; } 

प्रोजेक्ट्स प्रॉपर्टीज़ (गुण)> C / C ++ जनरल> पाथ्स एंड सिंबल्स> शामिल करने के लिए कॉमन एंड टेस्ट्स डायरेक्टरीज़ को सर्च पथ में जोड़ा जाना चाहिए।

मुख्य एल ई डी के साथ काम करने के लिए जोड़ें

 … /* USER CODE BEGIN Includes */ #include "led_counter.h" /* USER CODE END Includes */ … int main(void) { … /* USER CODE BEGIN WHILE */ Led_Counter_Init(); uint8_t led_state = 0; while (1) { /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ led_state = Led_Counter_Get_Next(); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, led_state & (1<<0)); HAL_GPIO_WritePin(GPIOE, GPIO_PIN_8, led_state & (1<<1)); HAL_Delay(500); } /* USER CODE END 3 */ … } 

परियोजना को संकलित और चलाना चाहिए, और एलईडी को झपकी लेना चाहिए।

लेखन परीक्षण

अब वह जिसके लिए सब कुछ शुरू किया गया था।

प्रोजेक्ट गुणों के माध्यम से एक नया बिल्ड कॉन्फ़िगरेशन बनाएं - गुण> C / C ++ बिल्ड> सेटिंग्स> कॉन्फ़िगरेशन प्रबंधित करें। क्यूबाइड आपको सिग्विन के तहत निर्माण के लिए कॉन्फ़िगरेशन बनाने की अनुमति नहीं देगा, इसलिए इसे उस परियोजना से कॉपी करें जिसे हमने पहले बनाया था:

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

• शामिल हैं - टेस्ट / इंक, कॉमन / इंक
• पुस्तकालय - gtest
• लाइब्रेरी पथ - टेस्ट / लीब
• स्रोत स्थान - / <prj_name> / Common और / <prj_name> / टेस्ट (प्रोजेक्ट नाम के साथ <prj_name> बदलें)

इसके बाद, प्रोजेक्ट में टेस्ट / लीब डायरेक्टरी में gtest लाइब्रेरी - .a फाइल को कॉपी करें और टेस्ट फाइल / इंक फोल्डर में gtest फोल्डर में हेडर फाइल करें। टेस्ट फ़ोल्डर में, एक नई main.cpp फ़ाइल बनाएं जिसमें परीक्षण चलाए जाएंगे। इसकी सामग्री मानक हैं:

main.cpp:

 /* * Unit tests main file */ #include "gtest/gtest.h" int main(int argc, char *argv[]) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } 

इसके अलावा, सेटअप का परीक्षण करने के लिए, हम एक परीक्षण बनाएंगे जो यह सत्यापित करेगा कि सूचक का आकार हमारे वातावरण में 32 बिट्स है (हम यह सुनिश्चित करना चाहते हैं कि यह माइक्रोकंट्रोलर पर भी ऐसा ही हो, इसके लिए हमने 32-बिट साइगविन निर्धारित किया है)।

निम्नलिखित test_platform.cpp परीक्षण फ़ाइल बनाएँ:

 #include "gtest/gtest.h" TEST(PlatformTest, TestPointerSize) { //Check pointer size is 32 bit ASSERT_EQ(sizeof(void*)*8, 32U); } 

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

परियोजना की संरचना कुछ इस तरह दिखनी चाहिए:

अब हम अपने एलईडी काउंटर मॉड्यूल के लिए परीक्षण लिखेंगे। परीक्षण फ़ाइलें टेस्ट फ़ोल्डर में स्थित हो सकती हैं:

 #include "gtest/gtest.h" extern "C" { #include "led_counter.h" } // Test fixture class LedCounterTest: public ::testing::Test { protected: void SetUp() { Led_Counter_Init(); } }; // Check initial value TEST_F(LedCounterTest, TestInitialValue) { Led_Counter_Init(); ASSERT_EQ(Led_Counter_Get_Next(), 1); } // Check how value is incremented TEST_F(LedCounterTest, TestIncrementValue) { Led_Counter_Init(); unsigned int val = Led_Counter_Get_Next(); for(int i=0;i<1;i++) { ASSERT_EQ(Led_Counter_Get_Next(), ++val); } } // Check how value return to 0 after 3 TEST_F(LedCounterTest, TestZeroCrossing) { Led_Counter_Init(); for(int i=0;i<3;i++) { Led_Counter_Get_Next(); } ASSERT_EQ(Led_Counter_Get_Next(), 0); } 

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

दिखाई देने वाले परिणामों के साथ एक विंडो के लिए, इसे विंडो> शो व्यू> अन्य> C / C ++> C / C ++ यूनिट में चुनें।

हो गया! अब परियोजना को संकलित किया जा सकता है और हमेशा की तरह लक्ष्य एमके के तहत चलाया जा सकता है। जब आपको स्थानीय परीक्षण चलाने की आवश्यकता होती है, जब आप रन टेस्ट कॉन्फ़िगरेशन चलाते हैं, तो परियोजना स्वतः x86 के लिए फिर से बनाई जाएगी, पर्यावरण परीक्षण चलाएगा और परिणाम दिखाएगा।

साहित्य

1. जे। ग्रेनिंग। एंबेडेड सी के लिए टेस्ट-प्रेरित विकास - एम्बेडेड सिस्टम की इकाई परीक्षण और टीडीडी पद्धति के आवेदन पर मौलिक काम।
2. https://uncannier.com/unit-testing-of-embedded-firmware-part-1-software-confucius/ - टेक्सास इंस्ट्रूमेंट्स कोड कंपोजर स्टूडियो, कैप्पेस्ट फ्रेमवर्क में यूनिट-परीक्षण x86 माइक्रोकंट्रोलर कोड
3. http://blog.atollic.com/why-running-your-embedded-arm-cortex-code-on-a-host-pc-is-a-good-thing - क्यों यह कोड चलाने के लिए उपयोगी हो सकता है पर एक लेख एक डेस्कटॉप प्लेटफॉर्म पर एक माइक्रोकंट्रोलर के लिए