A’ gluasad Qt gu STM32

Feasgar math Tha sinn sa phròiseact Bogsa a-steach Qt a chuir air bhog air STM32F7-Discovery agus bu mhath leotha bruidhinn mu dheidhinn. Na bu thràithe, dh’ innis sinn mu thràth mar a chaidh againn air cur air bhog OpenCV.

Tha Qt na fhrèam tar-àrd-ùrlar a tha a’ toirt a-steach chan e a-mhàin co-phàirtean grafaigeach, ach cuideachd rudan leithid QtNetwork, seata de chlasaichean airson a bhith ag obair le stòran-dàta, Qt airson Automation (a ’toirt a-steach buileachadh IoT) agus mòran a bharrachd. Tha an sgioba Qt air a bhith for-ghnìomhach mu bhith a’ cleachdadh Qt ann an siostaman freumhaichte, agus mar sin tha na leabharlannan gu math furasta an rèiteachadh. Ach, gu o chionn ghoirid, cha robh mòran dhaoine a 'smaoineachadh mu bhith a' giùlain Qt gu microcontrollers, is dòcha air sgàth 's gu bheil coltas gu bheil an leithid de dh' obair duilich - tha Qt mòr, tha MCUn beag.

Air an làimh eile, aig an àm seo tha microcontrollers air an dealbhadh gus obrachadh le ioma-mheadhan agus nas fheàrr na a ’chiad Pentiums. Mu bhliadhna air ais, nochd am blog Qt dreuchd. Rinn an luchd-leasachaidh port de Qt airson an RTEMS OS, agus chuir iad air bhog eisimpleirean le widgets air grunn bhùird a’ ruith stm32f7. Bha seo a’ toirt ùidh dhuinn. Bha e follaiseach, agus tha an luchd-leasachaidh fhèin a 'sgrìobhadh mu dheidhinn, gu bheil Qt slaodach air an STM32F7-Discovery. Bha sinn a’ faighneachd am b’ urrainn dhuinn Qt a ruith fo Embox, agus chan e a-mhàin widget a tharraing, ach beòthalachd a ruith.

Tha Qt 4.8 air a bhith air a ghluasad gu Embox airson ùine mhòr, agus mar sin chuir sinn romhainn feuchainn air. Thagh sinn an tagradh moveblocks - eisimpleir de bheòthalachd springy.

Qt moveblocks air QEMU

An toiseach, bidh sinn a’ rèiteachadh Qt, ma ghabhas e dèanamh, leis an t-seata as lugha de cho-phàirtean a dh’ fheumar gus taic a thoirt do bheòthalachd. Airson seo tha roghainn “-qconfig minimal, beag, meadhanach ....”. Bidh e a 'ceangal faidhle rèiteachaidh bho Qt le mòran macros - dè a nì thu comasach / dè a dhì-chomasachadh. Às deidh an roghainn seo, cuiridh sinn brataichean eile ris an rèiteachadh ma tha sinn airson rudeigin eile a chuir dheth. Seo eisimpleir de ar rèiteachadh.

Gus an obraich Qt, feumaidh tu còmhdach co-chòrdalachd OS a chuir ris. Is e aon dhòigh air QPA (Qt Platform Abstraction) a chuir an gnìomh. Ghabh sinn mar bhunait ris a’ plugan fb_base deiseil a tha air a ghabhail a-steach ann an Qt, air a bheil QPA airson Linux ag obair. Is e an toradh seo plugan beag ris an canar emboxfb, a bheir frèam-buffer Embox dha Qt, agus an uairsin bidh e a’ tarraing an sin gun chuideachadh bhon taobh a-muigh.

Seo mar a tha cruthachadh plugan coltach

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

Agus is e seo cò ris a bhios an ath-dhealbhadh coltach

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

Mar thoradh air an sin, leis an optimization compiler airson meud cuimhne -Os air a chomasachadh, thionndaidh ìomhaigh an leabharlainn gu bhith 3.5 MB, rud nach eil gu dearbh a ’freagairt air prìomh chuimhne an STM32F746. Mar a sgrìobh sinn mu thràth san artaigil eile againn mu OpenCV, tha am bòrd seo air:

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

Leis gu bheil taic airson còd a chuir an gnìomh bho QSPI air a chuir ri OpenCV mu thràth, chuir sinn romhainn tòiseachadh le bhith a’ luchdachadh an ìomhaigh Embox c Qt gu lèir gu QSPI. Agus Hurray, thòisich a h-uile càil cha mhòr sa bhad bho QSPI! Ach mar ann an cùis OpenCV, thionndaidh e a-mach gu bheil e ag obair ro shlaodach.

Mar sin, chuir sinn romhainn a dhèanamh mar seo - an toiseach bidh sinn a’ dèanamh lethbhreac den ìomhaigh gu QSPI, an uairsin ga luchdachadh gu SDRAM agus ga chuir an gnìomh às an sin. Bho SDRAM dh'fhàs e beagan na bu luaithe, ach fhathast fada bho QEMU.

An ath rud, bha beachd ann puing-fleòdraidh a ghabhail a-steach - às deidh a h-uile càil, bidh Qt a’ dèanamh beagan àireamhachadh de cho-chomharran cheàrnagan ann am beothachadh. Dh'fheuch sinn, ach an seo cha d 'fhuair sinn luathachadh faicsinneach sam bith, ged a bha sinn a-staigh artaigil Thuirt luchd-leasachaidh Qt gu bheil FPU a’ toirt àrdachadh mòr ann an astar airson “tarraing beòthalachd” air touchscreen. Is dòcha gu bheil mòran nas lugha de àireamhachadh puing-fleòdraidh ann am blocaichean gluasad, agus tha seo an urra ris an eisimpleir shònraichte.

B’ e am beachd a b’ èifeachdaiche am bufair frèam a ghluasad bho SDRAM gu cuimhne a-staigh. Gus seo a dhèanamh, rinn sinn na tomhasan sgrion chan e 480x272, ach 272x272. Lùghdaich sinn cuideachd an doimhneachd dath bho A8R8G8B8 gu R5G6B5, mar sin a’ lughdachadh meud aon piogsail bho 4 gu 2 bytes. Is e meud frèam bufair mar thoradh air sin 272 * 272 * 2 = 147968 bytes. Thug seo luathachadh mòr, is dòcha gu sònraichte, dh'fhàs am beòthalachd cha mhòr rèidh.

B ’e an optimization as ùire còd Embox a ruith bho RAM agus còd Qt bho SDRAM. Gus seo a dhèanamh, bidh sinn an-toiseach, mar as àbhaist, a’ ceangal Embox gu staitigeach ri Qt, ach bidh sinn a’ cur earrannan teacsa, rodata, dàta agus bss den leabharlann ann an QSPI gus an dèan sinn lethbhreac dheth gu 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))

Le bhith a’ cur an gnìomh còd Embox bho ROM, fhuair sinn luathachadh follaiseach cuideachd. Mar thoradh air an sin, thionndaidh am beòthalachd gu math rèidh:

Aig a’ cheann thall, fhad ‘s a bha e ag ullachadh an artaigil agus a’ feuchainn diofar rèiteachaidhean Embox, thionndaidh e a-mach gu bheil Qt moveblocks ag obair gu math bho QSPI le frèam bufair ann an SDRAM, agus bha am botail dìreach meud an fhrèam bufair! A rèir coltais, gus faighinn thairis air a’ chiad “taisbeanadh-shleamhnagan”, bha luathachadh dà-fhillte gu leòr mar thoradh air lughdachadh banal ann am meud an fhrèam bufair. Ach cha robh e comasach a leithid de thoradh a choileanadh le bhith a 'gluasad a' chòd Embox a-mhàin gu diofar chuimhneachain luath (cha robh an luaths 2, ach mu 2 uair).

Mar a nì thu feuchainn leat fhèin

Ma tha STM32F7-Discovery agad, faodaidh tu Qt a ruith fo Embox thu fhèin. Faodaidh tu leughadh mar a tha seo air a dhèanamh air ar wiki.

co-dhùnadh

Mar thoradh air an sin, chaidh againn air Qt! Tha iom-fhillteachd na h-obrach, nar beachd, rudeigin a 'dèanamh cus iomadachd. Gu nàdarra, feumaidh tu aire a thoirt do mhion-fhiosrachadh microcontrollers agus san fharsaingeachd tuigsinn ailtireachd siostaman coimpiutair. Tha na toraidhean optimization a’ nochdadh gu bheil fios againn nach e am pròiseasar a th’ anns a’ bhotail ann an siostam coimpiutaireachd, ach an cuimhne.

Am-bliadhna bidh sinn a’ gabhail pàirt anns an fhèis TechTrain. An sin innsidh sinn dhut nas mionaidiche agus seallaidh sinn Qt, OpenCV air microcontrollers agus na coileanaidhean eile againn.

Source: www.habr.com