Qt को STM32 में पोर्ट करना

शुभ दोपहर हम प्रोजेक्ट में हैं एमबॉक्स STM32F7-डिस्कवरी पर Qt लॉन्च किया और इसके बारे में बात करना चाहूंगा। हमने पहले ही बताया था कि हम कैसे लॉन्च करने में कामयाब रहे OpenCV.

Qt एक क्रॉस-प्लेटफ़ॉर्म फ़्रेमवर्क है जिसमें न केवल ग्राफिकल घटक शामिल हैं, बल्कि QtNetwork, डेटाबेस के साथ काम करने के लिए कक्षाओं का एक सेट, ऑटोमेशन के लिए Qt (IoT कार्यान्वयन सहित) और भी बहुत कुछ शामिल हैं। Qt टीम एम्बेडेड सिस्टम में Qt का उपयोग करने के बारे में सक्रिय रही है, इसलिए लाइब्रेरी काफी कॉन्फ़िगर करने योग्य हैं। हालाँकि, हाल तक, कुछ लोगों ने Qt को माइक्रोकंट्रोलर्स में पोर्ट करने के बारे में सोचा था, शायद इसलिए कि ऐसा कार्य मुश्किल लगता है - Qt बड़ा है, MCU छोटे हैं।

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

क्यूटी 4.8 को लंबे समय से एमबॉक्स में पोर्ट किया गया है, इसलिए हमने इस पर इसे आज़माने का फैसला किया। हमने मूवब्लॉक्स एप्लिकेशन को चुना - स्प्रिंगी एनीमेशन का एक उदाहरण।

QEMU पर क्यूटी मूवब्लॉक

आरंभ करने के लिए, यदि संभव हो तो हम एनीमेशन का समर्थन करने के लिए आवश्यक घटकों के न्यूनतम सेट के साथ Qt को कॉन्फ़िगर करते हैं। इसके लिए एक विकल्प है "-qconfig न्यूनतम, छोटा, मध्यम..."। यह Qt से एक कॉन्फ़िगरेशन फ़ाइल को कई मैक्रोज़ के साथ जोड़ता है - क्या सक्षम करना है / क्या अक्षम करना है। इस विकल्प के बाद, यदि हम कुछ और अक्षम करना चाहते हैं तो हम कॉन्फ़िगरेशन में अन्य झंडे जोड़ते हैं। यहाँ हमारा एक उदाहरण है विन्यास.

Qt को काम करने के लिए, आपको एक OS संगतता परत जोड़ने की आवश्यकता है। एक तरीका QPA (Qt प्लेटफ़ॉर्म एब्स्ट्रैक्शन) को लागू करना है। हमने Qt में शामिल रेडीमेड fb_base प्लगइन को आधार के रूप में लिया, जिसके आधार पर Linux के लिए QPA काम करता है। परिणाम एक छोटा प्लगइन है जिसे emboxfb कहा जाता है, जो Qt को Embox के फ़्रेमबफ़र के साथ प्रदान करता है, और फिर यह बिना किसी बाहरी मदद के वहां खींचता है।

प्लगइन बनाना कुछ इस तरह दिखता है

QEmboxFbIntegration::QEmboxFbIntegration()
    : fontDb(new QGenericUnixFontDatabase())
{
    struct fb_var_screeninfo vinfo;
    struct fb_fix_screeninfo finfo;
    const char *fbPath = "/dev/fb0";

    fbFd = open(fbPath, O_RDWR);
    if (fbPath < 0) {
        qFatal("QEmboxFbIntegration: Error open framebuffer %s", fbPath);
    }
    if (ioctl(fbFd, FBIOGET_FSCREENINFO, &finfo) == -1) {
        qFatal("QEmboxFbIntegration: Error ioctl framebuffer %s", fbPath);
    }
    if (ioctl(fbFd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
        qFatal("QEmboxFbIntegration: Error ioctl framebuffer %s", fbPath);
    }
    fbWidth        = vinfo.xres;
    fbHeight       = vinfo.yres;
    fbBytesPerLine = finfo.line_length;
    fbSize         = fbBytesPerLine * fbHeight;
    fbFormat       = vinfo.fmt;
    fbData = (uint8_t *)mmap(0, fbSize, PROT_READ | PROT_WRITE,
                             MAP_SHARED, fbFd, 0);
    if (fbData == MAP_FAILED) {
        qFatal("QEmboxFbIntegration: Error mmap framebuffer %s", fbPath);
    }
    if (!fbData || !fbSize) {
        qFatal("QEmboxFbIntegration: Wrong framebuffer: base = %p,"
               "size=%d", fbData, fbSize);
    }

    mPrimaryScreen = new QEmboxFbScreen(fbData, fbWidth,
                                        fbHeight, fbBytesPerLine,
                                        emboxFbFormatToQImageFormat(fbFormat));

    mPrimaryScreen->setPhysicalSize(QSize(fbWidth, fbHeight));
    mScreens.append(mPrimaryScreen);

    this->printFbInfo();
}

और पुनः आरेखण इस प्रकार दिखेगा

QRegion QEmboxFbScreen::doRedraw()
{
    QVector<QRect> rects;
    QRegion touched = QFbScreen::doRedraw();

    DPRINTF("QEmboxFbScreen::doRedrawn");

    if (!compositePainter) {
        compositePainter = new QPainter(mFbScreenImage);
    }

    rects = touched.rects();
    for (int i = 0; i < rects.size(); i++) {
        compositePainter->drawImage(rects[i], *mScreenImage, rects[i]);
    }
    return touched;
}

परिणामस्वरूप, मेमोरी साइज़ -ओएस के लिए कंपाइलर ऑप्टिमाइज़ेशन सक्षम होने पर, लाइब्रेरी छवि 3.5 एमबी हो गई, जो निश्चित रूप से STM32F746 की मुख्य मेमोरी में फिट नहीं होती है। जैसा कि हमने OpenCV के बारे में अपने अन्य लेख में पहले ही लिखा है, इस बोर्ड में है:

• 1 एमबी रॉम
• 320 केबी रैम
• 8 एमबी एसडीआरएएम
• 16 एमबी क्यूएसपीआई

चूँकि QSPI से कोड निष्पादित करने के लिए समर्थन OpenCV में पहले ही जोड़ा जा चुका है, इसलिए हमने संपूर्ण Embox c Qt छवि को QSPI में लोड करके शुरुआत करने का निर्णय लिया। और जल्दी, क्यूएसपीआई से सब कुछ लगभग तुरंत ही शुरू हो गया! लेकिन ओपनसीवी के मामले में, यह पता चला कि यह बहुत धीमी गति से काम करता है।

इसलिए, हमने इसे इस तरह से करने का निर्णय लिया - पहले हम छवि को QSPI पर कॉपी करते हैं, फिर इसे SDRAM में लोड करते हैं और वहां से निष्पादित करते हैं। SDRAM से यह थोड़ा तेज़ हो गया, लेकिन QEMU से अभी भी दूर है।

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

सबसे प्रभावी विचार फ़्रेमबफ़र को एसडीआरएएम से आंतरिक मेमोरी में स्थानांतरित करना था। ऐसा करने के लिए, हमने स्क्रीन का आयाम 480x272 नहीं, बल्कि 272x272 बनाया। हमने रंग की गहराई को A8R8G8B8 से घटाकर R5G6B5 कर दिया है, इस प्रकार एक पिक्सेल का आकार 4 से 2 बाइट्स तक कम हो गया है। परिणामी फ़्रेमबफ़र का आकार 272 * 272 * 2 = 147968 बाइट्स है। इससे एक महत्वपूर्ण तेजी आई, शायद सबसे उल्लेखनीय रूप से, एनीमेशन लगभग सुचारू हो गया।

नवीनतम अनुकूलन RAM से Embox कोड और SDRAM से Qt कोड चलाना था। ऐसा करने के लिए, हम पहले, हमेशा की तरह, स्थिर रूप से एमबॉक्स को क्यूटी के साथ जोड़ते हैं, लेकिन हम लाइब्रेरी के टेक्स्ट, रोडाटा, डेटा और बीएसएस सेगमेंट को क्यूएसपीआई में रखते हैं ताकि इसे एसडीआरएएम में कॉपी किया जा सके।

section (qt_text, SDRAM, QSPI)
phdr	(qt_text, PT_LOAD, FLAGS(5))

section (qt_rodata, SDRAM, QSPI)
phdr	(qt_rodata, PT_LOAD, FLAGS(5))

section (qt_data, SDRAM, QSPI)
phdr	(qt_data, PT_LOAD, FLAGS(6))

section (qt_bss, SDRAM, QSPI)
phdr	(qt_bss, PT_LOAD, FLAGS(6))

ROM से Embox कोड निष्पादित करके, हमें एक उल्लेखनीय त्वरण भी प्राप्त हुआ। परिणामस्वरूप, एनीमेशन काफी सहज हो गया:

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

इसे स्वयं कैसे आज़माएँ

यदि आपके पास STM32F7-डिस्कवरी है, तो आप स्वयं Embox के अंतर्गत Qt चला सकते हैं। आप पढ़ सकते हैं कि यह कैसे किया जाता है вики.

निष्कर्ष

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

इस वर्ष हम उत्सव में भाग लेंगे टेकट्रेन. वहां हम आपको अधिक विस्तार से बताएंगे और माइक्रोकंट्रोलर्स पर क्यूटी, ओपनसीवी और हमारी अन्य उपलब्धियां दिखाएंगे।

स्रोत: www.habr.com