Qtని STM32కి పోర్ట్ చేస్తోంది

శుభ మద్యాహ్నం మేము ప్రాజెక్ట్‌లో ఉన్నాము ఎంబాక్స్ STM32F7-డిస్కవరీలో Qtని ప్రారంభించింది మరియు దాని గురించి మాట్లాడాలనుకుంటున్నాను. ఇంతకుముందు, మేము ఎలా ప్రారంభించాలో ఇప్పటికే చెప్పాము OpenCV.

Qt అనేది క్రాస్-ప్లాట్‌ఫారమ్ ఫ్రేమ్‌వర్క్, ఇది గ్రాఫికల్ భాగాలను మాత్రమే కాకుండా, QtNetwork, డేటాబేస్‌లతో పని చేయడానికి తరగతుల సమితి, ఆటోమేషన్ కోసం Qt (IoT అమలుతో సహా) మరియు మరిన్నింటిని కలిగి ఉంటుంది. Qt బృందం ఎంబెడెడ్ సిస్టమ్‌లలో Qtని ఉపయోగించడం గురించి క్రియాశీలకంగా ఉంది, కాబట్టి లైబ్రరీలు చాలా కాన్ఫిగర్ చేయబడతాయి. అయినప్పటికీ, ఇటీవలి వరకు, కొంతమంది వ్యక్తులు క్యూటిని మైక్రోకంట్రోలర్‌లకు పోర్ట్ చేయడం గురించి ఆలోచించారు, బహుశా అలాంటి పని కష్టంగా అనిపించవచ్చు - Qt పెద్దది, MCUలు చిన్నవి.

మరోవైపు, ప్రస్తుతానికి మల్టీమీడియాతో పనిచేయడానికి మరియు మొదటి పెంటియమ్‌ల కంటే ఉన్నతమైన మైక్రోకంట్రోలర్‌లు ఉన్నాయి. ఒక సంవత్సరం క్రితం, Qt బ్లాగ్ కనిపించింది పోస్ట్. డెవలపర్లు RTEMS OS కోసం Qt యొక్క పోర్ట్‌ను తయారు చేసారు మరియు stm32f7 నడుస్తున్న అనేక బోర్డులపై విడ్జెట్‌లతో ఉదాహరణలను ప్రారంభించారు. ఇది మాకు ఆసక్తి కలిగించింది. STM32F7-డిస్కవరీలో Qt నెమ్మదిగా ఉందని ఇది గుర్తించదగినది మరియు డెవలపర్లు స్వయంగా దాని గురించి వ్రాస్తారు. మేము Embox క్రింద Qtని అమలు చేయగలమా, మరియు కేవలం విడ్జెట్‌ను గీయడం మాత్రమే కాకుండా, యానిమేషన్‌ను అమలు చేయగలమా అని మేము ఆలోచిస్తున్నాము.

Qt 4.8 చాలా కాలంగా Emboxకి పోర్ట్ చేయబడింది, కాబట్టి మేము దానిపై ప్రయత్నించాలని నిర్ణయించుకున్నాము. మేము మూవ్‌బ్లాక్స్ అప్లికేషన్‌ని ఎంచుకున్నాము - స్ప్రింగ్ యానిమేషన్‌కు ఉదాహరణ.

QEMUలో Qt మూవ్‌బ్లాక్‌లు

ప్రారంభించడానికి, మేము వీలైతే, యానిమేషన్‌కు మద్దతు ఇవ్వడానికి అవసరమైన కనీస భాగాల సెట్‌తో Qtని కాన్ఫిగర్ చేస్తాము. దీని కోసం “-qconfig minimal,small,medium...” అనే ఆప్షన్ ఉంది. ఇది Qt నుండి అనేక మాక్రోలతో కాన్ఫిగరేషన్ ఫైల్‌ను కలుపుతుంది - ఏమి ప్రారంభించాలి / ఏది నిలిపివేయాలి. ఈ ఐచ్ఛికం తర్వాత, మనం ఏదైనా డిసేబుల్ చేయాలనుకుంటే కాన్ఫిగరేషన్‌కి ఇతర ఫ్లాగ్‌లను జోడిస్తాము. ఇక్కడ మా ఉదాహరణ ఆకృతీకరణ.

Qt పని చేయడానికి, మీరు OS అనుకూలత లేయర్‌ని జోడించాలి. QPA (Qt ప్లాట్‌ఫారమ్ సంగ్రహణ) అమలు చేయడం ఒక మార్గం. మేము Qtలో చేర్చబడిన రెడీమేడ్ fb_base ప్లగిన్‌ని ప్రాతిపదికగా తీసుకున్నాము, దీని ఆధారంగా Linux కోసం QPA పనిచేస్తుంది. ఫలితం emboxfb అని పిలువబడే ఒక చిన్న ప్లగ్ఇన్, ఇది Embox యొక్క ఫ్రేమ్‌బఫర్‌తో 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 యొక్క ప్రధాన మెమరీకి సరిపోదు. మేము ఇప్పటికే OpenCV గురించి మా ఇతర కథనంలో వ్రాసినట్లుగా, ఈ బోర్డు కలిగి ఉంది:

• 1 MB ROM
• 320 KB ర్యామ్
• 8 MB SDRAM
• 16 MB QSPI

QSPI నుండి కోడ్‌ని అమలు చేయడానికి మద్దతు ఇప్పటికే OpenCVకి జోడించబడినందున, మేము మొత్తం Embox c Qt చిత్రాన్ని QSPIలోకి లోడ్ చేయడం ద్వారా ప్రారంభించాలని నిర్ణయించుకున్నాము. మరియు హుర్రే, ప్రతిదీ QSPI నుండి దాదాపు వెంటనే ప్రారంభమైంది! కానీ OpenCV విషయంలో వలె, ఇది చాలా నెమ్మదిగా పనిచేస్తుందని తేలింది.

అందువల్ల, మేము దీన్ని ఈ విధంగా చేయాలని నిర్ణయించుకున్నాము - ముందుగా మేము చిత్రాన్ని QSPIకి కాపీ చేసి, దానిని SDRAMలోకి లోడ్ చేసి, అక్కడ నుండి అమలు చేస్తాము. SDRAM నుండి ఇది కొంచెం వేగంగా మారింది, కానీ ఇప్పటికీ QEMU నుండి చాలా దూరంగా ఉంది.

తరువాత, ఫ్లోటింగ్ పాయింట్‌ని చేర్చాలనే ఆలోచన ఉంది - అన్నింటికంటే, యానిమేషన్‌లో స్క్వేర్‌ల అక్షాంశాల యొక్క కొన్ని గణనలను Qt చేస్తుంది. మేము ప్రయత్నించాము, కానీ ఇక్కడ మాకు కనిపించే త్వరణం లభించలేదు, అయినప్పటికీ వ్యాసం టచ్‌స్క్రీన్‌పై "డ్రాగింగ్ యానిమేషన్" కోసం FPU వేగాన్ని గణనీయంగా పెంచుతుందని Qt డెవలపర్లు పేర్కొన్నారు. మూవ్‌బ్లాక్‌లలో గణనీయంగా తక్కువ ఫ్లోటింగ్ పాయింట్ లెక్కలు ఉండవచ్చు మరియు ఇది నిర్దిష్ట ఉదాహరణపై ఆధారపడి ఉంటుంది.

ఫ్రేమ్‌బఫర్‌ను SDRAM నుండి అంతర్గత మెమరీకి తరలించడం అత్యంత ప్రభావవంతమైన ఆలోచన. దీన్ని చేయడానికి, మేము స్క్రీన్ కొలతలు 480x272 కాదు, 272x272 చేసాము. మేము A8R8G8B8 నుండి R5G6B5కి రంగు లోతును కూడా తగ్గించాము, తద్వారా ఒక పిక్సెల్ పరిమాణాన్ని 4 నుండి 2 బైట్‌లకు తగ్గించాము. ఫలితంగా ఫ్రేమ్‌బఫర్ పరిమాణం 272 * 272 * 2 = 147968 బైట్లు. ఇది గణనీయమైన త్వరణాన్ని అందించింది, బహుశా చాలా గమనించదగినది, యానిమేషన్ దాదాపు మృదువైనది.

RAM నుండి Embox కోడ్ మరియు SDRAM నుండి Qt కోడ్‌ని అమలు చేయడం తాజా ఆప్టిమైజేషన్. దీన్ని చేయడానికి, మేము ముందుగా, ఎప్పటిలాగే, Qtతో స్థిరంగా Emboxని లింక్ చేస్తాము, అయితే మేము దానిని SDRAMకి కాపీ చేయడానికి QSPIలో లైబ్రరీలోని టెక్స్ట్, రోడేటా, డేటా మరియు bss విభాగాలను ఉంచుతాము.

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