Gudde Mëtteg Mir sinn am Projet lancéiert Qt op STM32F7-Discovery a géif gären doriwwer ze schwätzen. Virdrun hu mir scho gesot wéi mir et fäerdeg bruecht hunn ze lancéieren .
Qt ass eng Kräiz-Plattform Kader datt net nëmmen grafesch Komponente enthält, awer och esou Saachen wéi QtNetwork, eng Formatioun vun Klassen fir eng Aarbecht mat Datenbanken, Qt fir Automatisatioun (och fir IoT Ëmsetzung) a vill méi. D'Qt Team war proaktiv iwwer d'Benotzung vu Qt an embedded Systemer, sou datt d'Bibliothéike ganz konfiguréierbar sinn. Wéi och ëmmer, bis viru kuerzem hu wéineg Leit geduecht fir Qt op Mikrokontroller ze portéieren, wahrscheinlech well sou eng Aufgab schwiereg schéngt - Qt ass grouss, MCUs si kleng.
Op der anerer Säit, am Moment ginn et Mikrokontroller entwéckelt fir mat Multimedia ze schaffen a méi héich wéi déi éischt Pentiums. Virun engem Joer ass de Qt Blog erschéngt . D'Entwéckler hunn en Hafen vu Qt fir d'RTEMS OS gemaach, a lancéiert Beispiller mat Widgets op e puer Brieder déi stm32f7 lafen. Dëst huet eis interesséiert. Et war bemierkenswäert, an d'Entwéckler selwer schreiwen doriwwer, datt Qt op der STM32F7-Discovery lues ass. Mir gewonnert, ob mir Qt ënner Embox lafen kéint, an net nëmmen e Widget-, mee lafen eng Animatioun.
Qt 4.8 gouf fir eng laang Zäit op Embox portéiert, also hu mir beschloss et ze probéieren. Mir hunn d'Moveblocks Applikatioun gewielt - e Beispill vu sprénger Animatioun.
Qt moveblocks op QEMU
Ze fänken mat, mir configuréieren Qt, wa méiglech, mat de Minimum Formatioun vun Komponente néideg Animatioun ze ënnerstëtzen. Fir dëst gëtt et eng Optioun "-qconfig minimal, small, medium ...". Et verbënnt eng Configuratiounsdatei aus Qt mat vill macros - wat ze aktivéieren / wat auszeschalten. No dëser Optioun addéiere mir aner Fändelen un d'Konfiguratioun wa mir soss eppes auszeschalten wëllen. Hei ass e Beispill vun eisem .
Fir datt Qt funktionnéiert, musst Dir eng OS Kompatibilitéitsschicht addéieren. Ee Wee ass QPA (Qt Plattform Abstraktioun) ëmzesetzen. Mir hunn als Basis de prett-feieren fb_base Plugin abegraff an Qt, op der Basis vun deem QPA fir Linux Wierker. D'Resultat ass e klenge Plugin genannt emboxfb, deen Qt mat dem Framebuffer vum Embox ubitt, an dann zitt et do ouni Hëllef vun baussen.
Dëst ass wéi e Plugin erstallt ausgesäit
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();
}
An esou wäert d'Redrawing ausgesinn
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;
}
Als Resultat, mat der Compiler Optimisatioun fir Memory Gréisst -Os aktivéiert, huet d'Bibliothéiksbild 3.5 MB erausgestallt, wat natierlech net an d'Haaptspeicher vum STM32F746 passt. Wéi mir schonn an eisem aneren Artikel iwwer OpenCV geschriwwen hunn, huet dëse Board:
- 1 MB ROM
- 320 KB RAM
- 8 MB SDRAM
- 16 MB QSPI
Zënter Ënnerstëtzung fir de Code aus QSPI auszeféieren ass schonn op OpenCV bäigefüügt, hu mir décidéiert fir unzefänken mam ganze Embbox c Qt Bild an QSPI ze lueden. An hurra, alles huet bal direkt vun QSPI ugefaangen! Mä wéi am Fall vun OpenCV, huet sech erausgestallt datt et ze lues funktionnéiert.
Dofir hu mir décidéiert et esou ze maachen - als éischt kopéiere mir d'Bild op QSPI, lued et dann an SDRAM an ausféieren vun do aus. Vun SDRAM gouf et e bësse méi séier, awer nach wäit vum QEMU.
Nächst war et eng Iddi e schwiewend Punkt ze enthalen - na, Qt puer Berechnungen vun de Koordinaten vun Plaze an Animatioun. Mir hu probéiert, awer hei hu mir keng sichtbar Beschleunegung kritt, obwuel an Qt Entwéckler behaapt datt FPU eng bedeitend Erhéijung vun der Geschwindegkeet gëtt fir "Animatioun ze zéien" op Touchscreen. Et kënne wesentlech manner Schwämmpunktberechnungen a Bewegungsblocken sinn, an dëst hänkt vum spezifesche Beispill of.
Déi effektivst Iddi war de Framebuffer vum SDRAM an d'intern Erënnerung ze réckelen. Fir dëst ze maachen, hu mir d'Dimensioune vum Écran net 480x272 gemaach, mee 272x272. Mir hunn och d'Faarfdéift vun A8R8G8B8 op R5G6B5 erofgesat, sou datt d'Gréisst vun engem Pixel vu 4 op 2 Bytes reduzéiert gëtt. Déi resultéierend Framebuffergréisst ass 272 * 272 * 2 = 147968 Bytes. Dëst huet eng bedeitend Beschleunegung ginn, vläicht am meeschte bemierkenswäert, d'Animatioun gouf bal glat.
Déi lescht Optimisatioun war den Embox Code vum RAM a Qt Code vun SDRAM ze lafen. Maachen dëst, mir éischt, wéi gewinnt, statesch Link Embox zesumme mat Qt, mä mir Plaz den Text, rodata, Donnéeën an bss Segmenter vun der Bibliothéik an QSPI fir eng Kopie et dann ze 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))
Andeems Dir den Embbox Code aus ROM ausféiert, hu mir och eng merkbar Beschleunegung kritt. Als Resultat ass d'Animatioun zimlech glat:
Um Enn, iwwerdeems den Artikel virbereeden an verschidden Embox Configuratioun probéieren, et huet sech erausgestallt, datt Qt moveblocks Wierker super aus QSPI mat engem Framebuffer an SDRAM, an der Flaschenhals war genee der Gréisst vun der Framebuffer! Anscheinend, fir déi initial "Slideshow" ze iwwerwannen, war eng 2-fache Beschleunegung genuch wéinst enger banaler Reduktioun vun der Gréisst vum Framebuffer. Awer et war net méiglech sou e Resultat z'erreechen andeems nëmmen den Embbox Code op verschidde séier Erënnerungen transferéiert gouf (d'Beschleunegung war net 2, awer ongeféier 1.5 Mol).
Wéi probéiert et selwer
Wann Dir hutt eng STM32F7-Entdeckung, Dir kënnt Qt ënner Embox selwer lafen. Dir kënnt liesen wéi dëst op eisem .
Konklusioun
Als Resultat hu mir et fäerdeg bruecht Qt ze starten! D'Komplexitéit vun der Aufgab ass eiser Meenung no e bëssen iwwerdriwwen. Natierlech musst Dir d'Spezifizitéite vu Mikrokontroller berücksichtegen an allgemeng d'Architektur vu Computersystemer verstoen. D'Optimiséierungsresultater weisen op de bekannte Fakt datt de Flaschenhals an engem Rechensystem net de Prozessor ass, mee d'Erënnerung.
Dëst Joer wäerte mir um Festival deelhuelen . Do wäerte mir Iech méi detailléiert soen a weisen Qt, OpenCV op Mikrokontroller an eis aner Leeschtungen.
Source: will.com