Qt க்கு STM32 க்கு போர்ட்டிங்

மதிய வணக்கம் நாங்கள் திட்டத்தில் இருக்கிறோம் எம்பாக்ஸ் STM32F7-Discovery இல் Qt ஐ அறிமுகப்படுத்தியது மற்றும் அதைப் பற்றி பேச விரும்புகிறேன். முன்னதாக, நாங்கள் எவ்வாறு தொடங்கினோம் என்பதை ஏற்கனவே கூறியுள்ளோம் ஓபன்சிவி.

Qt என்பது ஒரு குறுக்கு-தள கட்டமைப்பாகும், இது வரைகலை கூறுகள் மட்டுமல்ல, QtNetwork, தரவுத்தளங்களுடன் பணிபுரியும் வகுப்புகளின் தொகுப்பு, ஆட்டோமேஷனுக்கான Qt (IoT செயல்படுத்தல் உட்பட) மற்றும் பலவற்றையும் உள்ளடக்கியது. Qt குழு உட்பொதிக்கப்பட்ட அமைப்புகளில் Qt ஐப் பயன்படுத்துவதில் முனைப்புடன் உள்ளது, எனவே நூலகங்கள் மிகவும் கட்டமைக்கப்படுகின்றன. இருப்பினும், சமீப காலம் வரை, மைக்ரோகண்ட்ரோலர்களுக்கு க்யூடியை போர்ட் செய்வது பற்றி சிலர் நினைத்தார்கள், ஒருவேளை இதுபோன்ற பணி கடினமாகத் தோன்றுவதால் - க்யூடி பெரியது, எம்சியுக்கள் சிறியவை.

மறுபுறம், இந்த நேரத்தில் மல்டிமீடியாவுடன் வேலை செய்ய வடிவமைக்கப்பட்ட மைக்ரோகண்ட்ரோலர்கள் உள்ளன மற்றும் முதல் பென்டியம்களை விட உயர்ந்தவை. ஒரு வருடத்திற்கு முன்பு, Qt வலைப்பதிவு தோன்றியது பதவியை. டெவலப்பர்கள் RTEMS OS க்காக Qt இன் போர்ட்டை உருவாக்கினர், மேலும் stm32f7 இயங்கும் பல பலகைகளில் விட்ஜெட்களுடன் எடுத்துக்காட்டுகளை வெளியிட்டனர். இது எங்களுக்கு ஆர்வமாக இருந்தது. STM32F7-Discovery இல் Qt மெதுவாக உள்ளது என்பது கவனிக்கத்தக்கது மற்றும் டெவலப்பர்கள் இதைப் பற்றி எழுதுகிறார்கள். எம்பாக்ஸின் கீழ் க்யூடியை இயக்க முடியுமா, விட்ஜெட்டை மட்டும் வரையாமல், அனிமேஷனை இயக்க முடியுமா என்று யோசித்துக்கொண்டிருந்தோம்.

Qt 4.8 நீண்ட காலமாக எம்பாக்ஸுக்கு போர்ட் செய்யப்பட்டுள்ளது, எனவே அதை முயற்சிக்க முடிவு செய்தோம். நாங்கள் மூவ் பிளாக்ஸ் பயன்பாட்டைத் தேர்ந்தெடுத்தோம் - ஸ்பிரிங் அனிமேஷனின் உதாரணம்.

QEMU இல் Qt மூவ்பிளாக்ஸ்

தொடங்குவதற்கு, முடிந்தால், அனிமேஷனை ஆதரிக்க தேவையான குறைந்தபட்ச கூறுகளுடன் Qt ஐ உள்ளமைக்கிறோம். இதற்கு “-qconfig minimal,small,medium...” என்ற விருப்பம் உள்ளது. இது Qt இலிருந்து ஒரு உள்ளமைவு கோப்பை பல மேக்ரோக்களுடன் இணைக்கிறது - எதை இயக்குவது / எதை முடக்குவது. இந்த விருப்பத்திற்குப் பிறகு, வேறு ஏதாவது ஒன்றை முடக்க விரும்பினால், கட்டமைப்பில் மற்ற கொடிகளைச் சேர்க்கிறோம். எங்கள் ஒரு உதாரணம் இங்கே கட்டமைப்பு.

Qt வேலை செய்ய, நீங்கள் OS இணக்கத்தன்மை லேயரைச் சேர்க்க வேண்டும். QPA (Qt Platform Abstraction) செயல்படுத்துவது ஒரு வழி. Qt இல் சேர்க்கப்பட்டுள்ள ஆயத்த fb_base செருகுநிரலை நாங்கள் ஒரு அடிப்படையாக எடுத்துக் கொண்டோம், அதன் அடிப்படையில் Linux க்கான QPA வேலை செய்கிறது. இதன் விளைவாக emboxfb எனப்படும் சிறிய செருகுநிரல், இது எம்பாக்ஸின் பிரேம்பஃபருடன் 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 எம்பி ரோம்
• 320 KB ரேம்
• 8 எம்பி எஸ்டிராம்
• 16 எம்பி QSPI

QSPI இலிருந்து குறியீட்டை செயல்படுத்துவதற்கான ஆதரவு ஏற்கனவே OpenCV இல் சேர்க்கப்பட்டுள்ளதால், முழு Embox c Qt படத்தையும் QSPI இல் ஏற்றுவதன் மூலம் தொடங்க முடிவு செய்தோம். மற்றும் ஹர்ரே, எல்லாம் QSPI இலிருந்து உடனடியாக தொடங்கியது! ஆனால் OpenCV ஐப் போலவே, இது மிகவும் மெதுவாக வேலை செய்கிறது.

எனவே, இதை இந்த வழியில் செய்ய முடிவு செய்தோம் - முதலில் படத்தை QSPI க்கு நகலெடுத்து, அதை SDRAM இல் ஏற்றி அங்கிருந்து இயக்கவும். SDRAM இலிருந்து அது சற்று வேகமாக ஆனது, ஆனால் QEMU இலிருந்து இன்னும் வெகு தொலைவில் உள்ளது.

அடுத்து, ஒரு மிதக்கும் புள்ளியைச் சேர்க்க ஒரு யோசனை இருந்தது - எல்லாவற்றிற்கும் மேலாக, அனிமேஷனில் சதுரங்களின் ஆயங்களின் சில கணக்கீடுகளை Qt செய்கிறது. நாங்கள் முயற்சித்தோம், ஆனால் இங்கே காணக்கூடிய முடுக்கம் எதுவும் கிடைக்கவில்லை கட்டுரை க்யூடி டெவலப்பர்கள் தொடுதிரையில் "டிராக்கிங் அனிமேஷனுக்கான" வேகத்தில் குறிப்பிடத்தக்க அதிகரிப்பை FPU தருவதாகக் கூறினர். மூவ் பிளாக்குகளில் மிதக்கும் புள்ளிக் கணக்கீடுகள் கணிசமாகக் குறைவாக இருக்கலாம், மேலும் இது குறிப்பிட்ட உதாரணத்தைப் பொறுத்தது.

ஃப்ரேம்பஃபரை SDRAM இலிருந்து உள் நினைவகத்திற்கு நகர்த்துவது மிகவும் பயனுள்ள யோசனையாகும். இதைச் செய்ய, திரையின் பரிமாணங்களை 480x272 அல்ல, ஆனால் 272x272 ஆக்கினோம். வண்ண ஆழத்தை A8R8G8B8 இலிருந்து R5G6B5 ஆகக் குறைத்தோம், இதனால் ஒரு பிக்சலின் அளவை 4 முதல் 2 பைட்டுகளாகக் குறைத்தோம். இதன் விளைவாக ஃபிரேம்பஃபர் அளவு 272 * 272 * 2 = 147968 பைட்டுகள். இது ஒரு குறிப்பிடத்தக்க முடுக்கத்தை அளித்தது, ஒருவேளை மிகவும் குறிப்பிடத்தக்க வகையில், அனிமேஷன் கிட்டத்தட்ட மென்மையாக மாறியது.

ரேமில் இருந்து எம்பாக்ஸ் குறியீட்டையும், எஸ்டிஆர்ஏமில் இருந்து க்யூடி குறியீட்டையும் இயக்குவதே சமீபத்திய தேர்வுமுறை. இதைச் செய்ய, நாங்கள் முதலில், வழக்கம் போல், எம்பாக்ஸை Qt உடன் நிலையான முறையில் இணைக்கிறோம், ஆனால் நூலகத்தின் உரை, ரோடேட்டா, தரவு மற்றும் பிஎஸ்எஸ் பிரிவுகளை 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 இலிருந்து எம்பாக்ஸ் குறியீட்டை இயக்குவதன் மூலம், நாங்கள் குறிப்பிடத்தக்க முடுக்கத்தையும் பெற்றோம். இதன் விளைவாக, அனிமேஷன் மிகவும் மென்மையாக மாறியது:

இறுதியில், கட்டுரையைத் தயாரித்து, வெவ்வேறு எம்பாக்ஸ் உள்ளமைவுகளை முயற்சிக்கும்போது, ​​Qt மூவ்பிளாக்ஸ் QSPI இலிருந்து SDRAM இல் ஒரு பிரேம்பஃபருடன் சிறப்பாகச் செயல்படுகிறது, மேலும் தடையானது பிரேம்பஃபரின் அளவு துல்லியமாக இருந்தது! வெளிப்படையாக, ஆரம்ப “ஸ்லைடுஷோ” ஐக் கடக்க, ஃபிரேம்பஃபரின் அளவு சாதாரணமான குறைப்பு காரணமாக 2 மடங்கு முடுக்கம் போதுமானதாக இருந்தது. ஆனால் எம்பாக்ஸ் குறியீட்டை மட்டும் பல்வேறு வேகமான நினைவுகளுக்கு மாற்றுவதன் மூலம் அத்தகைய முடிவை அடைய முடியவில்லை (வேகமானது 2 அல்ல, ஆனால் சுமார் 1.5 மடங்கு).

அதை நீங்களே முயற்சி செய்வது எப்படி

உங்களிடம் STM32F7-டிஸ்கவரி இருந்தால், நீங்களே எம்பாக்ஸின் கீழ் Qt ஐ இயக்கலாம். இது எவ்வாறு செய்யப்படுகிறது என்பதை நீங்கள் படிக்கலாம் விக்கி.

முடிவுக்கு

இதன் விளைவாக, நாங்கள் Qt ஐ அறிமுகப்படுத்த முடிந்தது! பணியின் சிக்கலானது, எங்கள் கருத்துப்படி, ஓரளவு மிகைப்படுத்தப்பட்டதாகும். இயற்கையாகவே, நீங்கள் மைக்ரோகண்ட்ரோலர்களின் பிரத்தியேகங்களை கணக்கில் எடுத்துக்கொள்ள வேண்டும் மற்றும் பொதுவாக கணினி அமைப்புகளின் கட்டமைப்பைப் புரிந்து கொள்ள வேண்டும். தேர்வுமுறை முடிவுகள், கணினி அமைப்பில் உள்ள இடையூறு செயலி அல்ல, நினைவகம் என்பது நன்கு அறியப்பட்ட உண்மையைச் சுட்டிக்காட்டுகிறது.

இந்த ஆண்டு திருவிழாவில் பங்கேற்போம் தொழில்நுட்ப ரயில். அங்கு நாங்கள் உங்களுக்கு இன்னும் விரிவாகக் கூறுவோம் மற்றும் மைக்ரோகண்ட்ரோலர்களில் க்யூடி, ஓபன்சிவி மற்றும் எங்கள் பிற சாதனைகளைக் காண்பிப்போம்.

ஆதாரம்: www.habr.com