Portering av Qt til STM32

Portering av Qt til STM32God dag! Vi i prosjektet Embox har startet Qt på STM32F7-Discovery og ønsker å fortelle om det. Tidligere har vi allerede fortalt hvordan vi fikk startet OpenCV.

Qt er et tverrplattform rammeverk som ikke bare inkluderer grafiske komponenter, men også ting som QtNetwork, et sett med klasser for databasehåndtering, Qt for Automation (inkludert for implementering av IoT) og mye mer. Utviklerne av Qt-teamet forutså bruken av Qt i innebygde systemer, og derfor er bibliotekene ganske godt konfigurerbare. Imidlertid, inntil nylig, var det få som tenkte på å portere Qt til mikrokontrollere, sannsynligvis fordi oppgaven så komplisert ut — Qt er stort, MCU-er er små.

På den annen side finnes det nå mikrokontrollere laget for multimedia som overgår de tidlige Pentiumene. For omtrent et år siden dukket det opp på Qt-bloggen a post. Utviklerne porterte Qt for RTEMS, og kjørte eksempler med widgets på flere kort drevet av stm32f7. Dette vekket vår interesse. Det var merkbart, og utviklerne selv skriver om det, at Qt er tregt på STM32F7-Discovery. Vi ble nysgjerrige på om vi kunne kjøre Qt på Embox, og ikke bare lage en widget, men også kjøre animasjonen.

Qt 4.8 har lenge vært portert til Embox, så vi bestemte oss for å prøve det. Vi valgte applikasjonen moveblocks — et eksempel på fjærende animasjon.

Qt moveblocks på QEMUPortering av Qt til STM32

Først konfigurerer vi Qt med et minimal sett komponenter nødvendig for å støtte animasjonen. Det er en mulighet “-qconfig minimal,small,medium …”. Den kobler til en konfigurasjonsfil fra Qt med mange makroer — hva som skal aktiveres / hva som skal deaktiveres. Etter denne opsjonen legger vi til andre flagg i konfigurasjonen hvis vi ønsker å deaktivere enda mer. Her er et eksempel på vår konfigurasjon.

For at Qt skal fungere, må vi legge til et lag med kompatibilitet med OS. En av måtene er å implementere QPA (Qt Platform Abstraction). Vi tok grunnlaget fra en allerede eksisterende plugin fb_base fra Qt, som er grunnlaget for QPA for Linux. Resultatet ble en liten plugin emboxfb, som gir Qt rammebufferen til Embox, og deretter tegner det der uten ytterligere hjelp.

Slik ser opprettelsen av plugin ut

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 setPhysicalSize(QSize(fbWidth, fbHeight));
    mScreens.append(mPrimaryScreen);

    this->printFbInfo();
}

Slik vil omtegning se ut

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

    DPRINTF("QEmboxFbScreen::doRedrawn");

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

    rects = touched.rects();
    for (int i = 0; i drawImage(rects[i], *mScreenImage, rects[i]);
    }
    return touched;
}

Som et resultat av å ha aktivert kompilatorens minneoptimering -Os, ble bibliotekavbildningen 3.5 MB, noe som selvsagt ikke passer inn i hovedminnet til STM32F746. Som vi allerede har nevnt i en annen artikkel om OpenCV, har dette brettet:

  • 1 MB ROM
  • 320 KB RAM
  • 8 MB SDRAM
  • 16 MB QSPI

Siden OpenCV allerede hadde fått lagt til støtte for kodeeksekvering fra QSPI, bestemte vi oss for å laste hele Embox-avbildningen med Qt til QSPI. Og hurra, alt startet nesten umiddelbart fra QSPI! Men, som med OpenCV, viste det seg at det fungerer altfor sakte.

Portering av Qt til STM32

Derfor bestemte vi oss for å gjøre det på denne måten — først kopiere avbildningen til QSPI, deretter laste den til SDRAM og kjøre fra der. Det ble litt raskere fra SDRAM, men fortsatt langt unna QEMU.

Portering av Qt til STM32

Videre var ideen å aktivere flyttallsmodulen — ettersom Qt gjør noen beregninger av koordinater for firkanter i animasjonen. Vi prøvde, men her fikk vi ikke synlig mer fart, selv om artikkelen Qt-utviklerne hevdet at FPU gir betydelig økning i hastighet for 'dragging animation' på berøringsskjerm. Kanskje det er betydelig færre beregninger med flyttall i moveblocks, og dette avhenger av det spesifikke eksempelet.

Den mest effektive løsningen viste seg å være å flytte framebufferen fra SDRAM til det interne minnet. For dette gjorde vi skjermstørrelsen fra 480×272 til 272×272. Vi reduserte også fargedybden fra A8R8G8B8 til R5G6B5, noe som reduserte størrelsen på én piksel fra 4 til 2 byte. Vi fikk størrelsen på framebufferen til å være 272 * 272 * 2 = 147968 byte. Dette ga en betydelig hastighetsøkning, sannsynligvis den mest merkbare, animasjonen ble nesten jevn.

Den siste optimaliseringen var å kjøre koden til Embox fra RAM mens Qt ble kjørt fra SDRAM. For dette lenket vi først Embox sammen med Qt statisk som vanlig, men vi plasserte segmentene text, rodata, data og bss fra biblioteket i QSPI, for så å kopiere dem til 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))

Ved å kjøre koden til Embox fra ROM oppnådde vi også en merkbar hastighetsøkning. Resultatet er at animasjonen ble ganske jevn:

Spill video

Allerede mot slutten, mens vi forberedte artikkelen og prøvde ulike konfigurasjoner av Embox, fant vi ut at Qt moveblocks fungerer utmerket fra QSPI med framebufferen i SDRAM, og det som var flaskehalsen var selve størrelsen på framebufferen! Tydeligvis var det tilstrekkelig med en dobling av hastigheten bare ved å redusere størrelsen på framebufferen. Ved kun å flytte koden til Embox til forskjellige raske minnetyper oppnådde vi ikke et sånt resultat (hastighetsøkningen var ikke 2, men omtrent 1.5 ganger).

Hvordan prøve selv

Hvis du har en STM32F7-Discovery, kan du selv kjøre Qt under Embox. Du kan lese hvordan dette gjøres på vår wiki.

Konklusjon

Til slutt fikk vi Qt til å kjøre! Vanskelighetsgraden av oppgaven, etter vår mening, er noe overdrevet. Det er naturligvis viktig å ta hensyn til spesifikasjonene til mikrokontrollere og generelt forstå arkitekturen til databehandlingssystemer. Optimaliseringsresultatene peker på den kjente fakta om at det mest kritiske punktet i et databehandlingssystem ikke er prosessoren, men minnet.

I år skal vi delta på festivalen TechTrain. Der vil vi gå mer i dybden på og vise Qt, OpenCV på mikrokontrollere, og våre andre prestasjoner.

Kilde: habr.com

Kjøp pålitelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere 🔥 Kjøp pålitelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere | ProHoster