STM32 પર Qt પોર્ટિંગ

શુભ બપોર અમે પ્રોજેક્ટમાં છીએ એમ્બોક્સ STM32F7-Discovery પર Qt લૉન્ચ કર્યું અને તેના વિશે વાત કરવા માંગુ છું. અગાઉ, અમે પહેલેથી જ કહ્યું હતું કે અમે કેવી રીતે લોન્ચ કરવામાં સફળ થયા ઓપનસીવી.

Qt એ ક્રોસ-પ્લેટફોર્મ ફ્રેમવર્ક છે જેમાં માત્ર ગ્રાફિકલ ઘટકો જ નહીં, પણ QtNetwork, ડેટાબેઝ સાથે કામ કરવા માટેના વર્ગોનો સમૂહ, ઑટોમેશન માટે Qt (IoT અમલીકરણ સહિત) અને ઘણું બધું શામેલ છે. Qt ટીમ એમ્બેડેડ સિસ્ટમ્સમાં Qt નો ઉપયોગ કરવા માટે સક્રિય રહી છે, તેથી પુસ્તકાલયો તદ્દન રૂપરેખાંકિત છે. જો કે, તાજેતરમાં સુધી, થોડા લોકોએ Qt ને માઇક્રોકન્ટ્રોલર્સમાં પોર્ટ કરવા વિશે વિચાર્યું, કદાચ કારણ કે આવા કાર્ય મુશ્કેલ લાગે છે - Qt મોટું છે, MCU નાના છે.

બીજી બાજુ, આ ક્ષણે મલ્ટિમીડિયા સાથે કામ કરવા માટે રચાયેલ માઇક્રોકન્ટ્રોલર્સ છે અને પ્રથમ પેન્ટિયમ્સથી શ્રેષ્ઠ છે. લગભગ એક વર્ષ પહેલાં, Qt બ્લોગ દેખાયો પોસ્ટ. વિકાસકર્તાઓએ RTEMS OS માટે Qt નો પોર્ટ બનાવ્યો, અને stm32f7 ચલાવતા કેટલાક બોર્ડ પર વિજેટ્સ સાથે ઉદાહરણો શરૂ કર્યા. આ અમને રસ હતો. તે નોંધનીય હતું, અને વિકાસકર્તાઓ પોતે તેના વિશે લખે છે, કે STM32F7-ડિસ્કવરી પર Qt ધીમું છે. અમે વિચારી રહ્યા હતા કે શું આપણે Embox હેઠળ Qt ચલાવી શકીએ, અને માત્ર વિજેટ દોરવા નહીં, પણ એનિમેશન ચલાવી શકીએ.

Qt 4.8 લાંબા સમયથી Embox પર પોર્ટ કરવામાં આવ્યું છે, તેથી અમે તેને તેના પર અજમાવવાનું નક્કી કર્યું છે. અમે મૂવબ્લોક એપ્લિકેશન પસંદ કરી છે - સ્પ્રિંગી એનિમેશનનું ઉદાહરણ.

QEMU પર Qt મૂવબ્લૉક્સ

શરૂ કરવા માટે, અમે એનિમેશનને સપોર્ટ કરવા માટે જરૂરી ઘટકોના ન્યૂનતમ સેટ સાથે, જો શક્ય હોય તો, Qt ગોઠવીએ છીએ. આ માટે "-qconfig મિનિમલ, સ્મોલ, મીડિયમ..." વિકલ્પ છે. તે Qt થી રૂપરેખાંકન ફાઇલને ઘણા મેક્રો સાથે જોડે છે - શું સક્ષમ કરવું / શું અક્ષમ કરવું. આ વિકલ્પ પછી, અમે રૂપરેખાંકનમાં અન્ય ફ્લેગ ઉમેરીએ છીએ જો આપણે કંઈક બીજું અક્ષમ કરવા માંગતા હોઈએ. અહીં અમારા એક ઉદાહરણ છે રૂપરેખાંકન.

Qt કાર્ય કરવા માટે, તમારે OS સુસંગતતા સ્તર ઉમેરવાની જરૂર છે. એક રસ્તો QPA (Qt પ્લેટફોર્મ એબ્સ્ટ્રેક્શન) ને અમલમાં મૂકવાનો છે. અમે Qt માં સમાવિષ્ટ તૈયાર fb_base પ્લગઇનને આધાર તરીકે લીધો, જેના આધારે Linux માટે QPA કામ કરે છે. પરિણામ એ એમબોક્સએફબી નામનું એક નાનું પ્લગઇન છે, જે એમ્બોક્સના ફ્રેમબફર સાથે Qt પ્રદાન કરે છે, અને પછી તે બહારની કોઈ મદદ વિના ત્યાં દોરે છે.

પ્લગઇન બનાવવાનું આ જેવું દેખાય છે

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;
}

પરિણામે, મેમરી સાઈઝ -Os માટે કમ્પાઈલર ઓપ્ટિમાઈઝેશન સક્ષમ થવાથી, લાઈબ્રેરી ઈમેજ 3.5 MB ની બહાર આવી, જે અલબત્ત STM32F746 ની મુખ્ય મેમરીમાં બંધબેસતી નથી. જેમ કે અમે ઓપનસીવી વિશે અમારા અન્ય લેખમાં પહેલેથી જ લખ્યું છે, આ બોર્ડ પાસે છે:

• 1 એમબી રોમ
• 320 KB રેમ
• 8 MB SDRAM
• 16 MB QSPI

QSPI તરફથી કોડ ચલાવવા માટે સપોર્ટ પહેલેથી જ OpenCV માં ઉમેરવામાં આવ્યો હોવાથી, અમે QSPI માં સમગ્ર Embox c Qt ઇમેજ લોડ કરીને પ્રારંભ કરવાનું નક્કી કર્યું છે. અને હુરે, QSPI થી લગભગ તરત જ બધું શરૂ થયું! પરંતુ OpenCV ના કિસ્સામાં, તે બહાર આવ્યું છે કે તે ખૂબ ધીમેથી કામ કરે છે.

તેથી, અમે તેને આ રીતે કરવાનું નક્કી કર્યું - પહેલા અમે ઇમેજને QSPI પર કૉપિ કરીએ છીએ, પછી તેને SDRAM માં લોડ કરીએ છીએ અને ત્યાંથી એક્ઝિક્યુટ કરીએ છીએ. SDRAM થી તે થોડું ઝડપી બન્યું, પરંતુ હજુ પણ QEMU થી દૂર છે.

આગળ, ફ્લોટિંગ પોઈન્ટનો સમાવેશ કરવાનો વિચાર હતો - છેવટે, Qt એનિમેશનમાં ચોરસના કોઓર્ડિનેટ્સની કેટલીક ગણતરીઓ કરે છે. અમે પ્રયાસ કર્યો, પરંતુ અહીં અમને કોઈ દૃશ્યમાન પ્રવેગ મળ્યો નથી, તેમ છતાં લેખ Qt વિકાસકર્તાઓએ દાવો કર્યો હતો કે FPU ટચસ્ક્રીન પર "ડ્રેગિંગ એનિમેશન" માટે ઝડપમાં નોંધપાત્ર વધારો કરે છે. મૂવબ્લોક્સમાં નોંધપાત્ર રીતે ઓછી ફ્લોટિંગ પોઈન્ટ ગણતરીઓ હોઈ શકે છે, અને આ ચોક્કસ ઉદાહરણ પર આધાર રાખે છે.

ફ્રેમબફરને SDRAM થી આંતરિક મેમરીમાં ખસેડવાનો સૌથી અસરકારક વિચાર હતો. આ કરવા માટે, અમે સ્ક્રીનના પરિમાણોને 480x272 નહીં, પરંતુ 272x272 બનાવ્યાં છે. અમે A8R8G8B8 થી R5G6B5 સુધી રંગની ઊંડાઈ પણ ઘટાડી છે, આમ એક પિક્સેલનું કદ 4 થી 2 બાઇટ્સ ઘટાડ્યું છે. પરિણામી ફ્રેમબફરનું કદ 272 * 272 * 2 = 147968 બાઇટ્સ છે. આનાથી નોંધપાત્ર પ્રવેગક થયો, કદાચ સૌથી નોંધપાત્ર રીતે, એનિમેશન લગભગ સરળ બન્યું.

નવીનતમ ઑપ્ટિમાઇઝેશન RAM માંથી Embox કોડ અને SDRAM માંથી Qt કોડ ચલાવવાનું હતું. આ કરવા માટે, અમે પહેલા, હંમેશની જેમ, સ્ટેટિકલી એમ્બૉક્સને Qt સાથે જોડીએ છીએ, પરંતુ અમે લાઇબ્રેરીના ટેક્સ્ટ, રોડેટા, ડેટા અને bss સેગમેન્ટ્સને QSPI માં મૂકીએ છીએ જેથી પછી તેને SDRAM પર કૉપિ કરી શકાય.

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 કોડને એક્ઝિક્યુટ કરીને, અમને નોંધપાત્ર પ્રવેગક પણ પ્રાપ્ત થયો. પરિણામે, એનિમેશન એકદમ સરળ બન્યું:

ખૂબ જ અંતમાં, લેખ તૈયાર કરતી વખતે અને વિવિધ એમ્બોક્સ રૂપરેખાંકનોનો પ્રયાસ કરતી વખતે, તે બહાર આવ્યું કે QT મૂવબ્લોક્સ SDRAM માં ફ્રેમબફર સાથે QSPI માંથી સરસ કામ કરે છે, અને અડચણ ચોક્કસપણે ફ્રેમબફરના કદની હતી! દેખીતી રીતે, પ્રારંભિક "સ્લાઇડશો" ને દૂર કરવા માટે, ફ્રેમબફરના કદમાં મામૂલી ઘટાડાને કારણે 2-ગણો પ્રવેગક પૂરતો હતો. પરંતુ માત્ર એમ્બોક્સ કોડને વિવિધ ઝડપી સ્મૃતિઓમાં સ્થાનાંતરિત કરીને આવા પરિણામ પ્રાપ્ત કરવું શક્ય ન હતું (પ્રવેગક 2 ન હતો, પરંતુ લગભગ 1.5 ગણો હતો).

તેને જાતે કેવી રીતે અજમાવવું

જો તમારી પાસે STM32F7-ડિસ્કવરી છે, તો તમે જાતે જ Embox હેઠળ Qt ચલાવી શકો છો. તમે અમારા પર આ કેવી રીતે કરવામાં આવે છે તે વાંચી શકો છો વિકી.

નિષ્કર્ષ

પરિણામે, અમે Qt લોન્ચ કરવામાં વ્યવસ્થાપિત થયા! કાર્યની જટિલતા, અમારા મતે, કંઈક અંશે અતિશયોક્તિપૂર્ણ છે. સ્વાભાવિક રીતે, તમારે માઇક્રોકન્ટ્રોલર્સની વિશિષ્ટતાઓને ધ્યાનમાં લેવાની અને સામાન્ય રીતે કમ્પ્યુટર સિસ્ટમ્સના આર્કિટેક્ચરને સમજવાની જરૂર છે. ઑપ્ટિમાઇઝેશન પરિણામો જાણીતી હકીકત તરફ નિર્દેશ કરે છે કે કમ્પ્યુટિંગ સિસ્ટમમાં અવરોધ પ્રોસેસર નથી, પરંતુ મેમરી છે.

આ વર્ષે અમે ઉત્સવમાં ભાગ લઈશું ટેકટ્રેન. ત્યાં અમે તમને વધુ વિગતવાર જણાવીશું અને માઇક્રોકન્ટ્રોલર પર Qt, OpenCV અને અમારી અન્ય સિદ્ધિઓ બતાવીશું.

સોર્સ: www.habr.com