העברת Qt ל-STM32

אחר הצהריים טובים אנחנו בפרויקט אמבוקס השיק Qt ב- STM32F7-Discovery ורוצה לדבר על זה. קודם כבר סיפרנו איך הצלחנו להשיק OpenCV.

Qt היא מסגרת חוצת פלטפורמות הכוללת לא רק רכיבים גרפיים, אלא גם דברים כמו QtNetwork, סט של מחלקות לעבודה עם מסדי נתונים, Qt for Automation (כולל להטמעת IoT) ועוד הרבה יותר. צוות Qt היה פרואקטיבי בשימוש ב-Qt במערכות משובצות, כך שהספריות ניתנות להגדרה. עם זאת, עד לאחרונה, מעטים חשבו על העברת Qt למיקרו-בקרים, כנראה בגלל שמשימה כזו נראית קשה - Qt גדול, MCUs קטנים.

מצד שני, כרגע יש מיקרו-בקרים המיועדים לעבוד עם מולטימדיה ועולים על פני הפנטיום הראשונים. לפני כשנה הופיע הבלוג Qt להציב. המפתחים עשו יציאה של Qt עבור מערכת ההפעלה RTEMS, והשיקו דוגמאות עם ווידג'טים במספר לוחות שמריצים stm32f7. זה עניין אותנו. היה מורגש, והמפתחים עצמם כותבים על כך, ש-Qt איטי ב-STM32F7-Discovery. תהינו אם נוכל להריץ Qt תחת Embox, ולא רק לצייר ווידג'ט, אלא להריץ אנימציה.

Qt 4.8 הועבר ל-Embox במשך זמן רב, אז החלטנו לנסות אותו עליו. בחרנו באפליקציית moveblocks - דוגמה לאנימציה קפיצית.

Qt moveblocks על QEMU

מלכתחילה, אנו מגדירים את Qt, אם אפשר, עם סט הרכיבים המינימלי הנדרש לתמיכה באנימציה. בשביל זה יש אפשרות "-qconfig minimal,small, medium...". הוא מחבר קובץ תצורה מ-Qt עם פקודות מאקרו רבות - מה להפעיל / מה לבטל. לאחר אפשרות זו, נוסיף דגלים נוספים לתצורה אם ברצוננו להשבית משהו אחר. הנה דוגמה שלנו תְצוּרָה.

כדי ש-Qt יעבוד, עליך להוסיף שכבת תאימות למערכת ההפעלה. דרך אחת היא ליישם QPA (Qt Platform Abstraction). לקחנו כבסיס את התוסף fb_base המוכן הכלול ב-Qt, שעל בסיסו עובד QPA עבור לינוקס. התוצאה היא תוסף קטן בשם emboxfb, שמספק ל-Qt את ה-framebuffer של Embox, ואז הוא מצייר לשם ללא כל עזרה מבחוץ.

כך נראית יצירת תוסף

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 מגה-בייט, מה שכמובן לא נכנס לזיכרון הראשי של ה-STM32F746. כפי שכבר כתבנו במאמר אחר שלנו על OpenCV, ללוח הזה יש:

• 1 MB ROM
• זיכרון RAM של 320 KB
• 8 MB SDRAM
• 16 MB QSPI

מכיוון שכבר נוספה ל-OpenCV תמיכה בביצוע קוד מ-QSPI, החלטנו להתחיל בטעינת כל תמונת ה-Embox c Qt לתוך QSPI. והיה, הכל התחיל כמעט מיד מ-QSPI! אבל כמו במקרה של OpenCV, התברר שהוא עובד לאט מדי.

לכן, החלטנו לעשות את זה כך - קודם כל נעתיק את התמונה ל-QSPI, ואז נטענים אותה ל-SDRAM ונבצע משם. מ-SDRAM זה נהיה קצת יותר מהיר, אבל עדיין רחוק מ-QEMU.

לאחר מכן, היה רעיון לכלול נקודה צפה - אחרי הכל, Qt עושה כמה חישובים של הקואורדינטות של ריבועים באנימציה. ניסינו, אבל כאן לא קיבלנו שום תאוצה נראית לעין, אם כי פנימה статье מפתחי Qt טענו כי FPU נותן עלייה משמעותית במהירות עבור "גרירת אנימציה" על מסך מגע. ייתכן שיש פחות חישובי נקודה צפה ב-moveblocks באופן משמעותי, וזה תלוי בדוגמה הספציפית.

הרעיון היעיל ביותר היה להעביר את ה-framebuffer מ-SDRAM לזיכרון פנימי. לשם כך, עשינו את מידות המסך לא 480x272, אלא 272x272. הורדנו גם את עומק הצבע מ-A8R8G8B8 ל-R5G6B5, ובכך הקטינו את גודלו של פיקסל אחד מ-4 ל-2 בתים. גודל ה-framebuffer המתקבל הוא 272*272*2 = 147968 בתים. זה נתן האצה משמעותית, אולי הכי בולטת, האנימציה הפכה כמעט חלקה.

האופטימיזציה האחרונה הייתה להפעיל את קוד ה-Embox מ-RAM וקוד Qt מ-SDRAM. לשם כך, אנו קודם, כרגיל, מקשרים את Embox באופן סטטי עם Qt, אך אנו מניחים את מקטעי הטקסט, ה-rodata, הנתונים וה-bss של הספרייה ב-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))

על ידי הפעלת קוד ה-Embox מ-ROM, קיבלנו גם האצה ניכרת. כתוצאה מכך, האנימציה יצאה חלקה למדי:

ממש בסוף, תוך כדי הכנת הכתבה וניסיון תצורות שונות של Embox, התברר ש-Qt moveblocks עובד מצוין מ-QSPI עם framebuffer ב-SDRAM, וצוואר הבקבוק היה בדיוק בגודל של ה-framebuffer! ככל הנראה, כדי להתגבר על "מצגת השקופיות" הראשונית, הספיקה תאוצה פי 2 עקב הקטנה בנאלית בגודל ה-framebuffer. אבל לא ניתן היה להגיע לתוצאה כזו על ידי העברת קוד ה-Embox בלבד לזכרונות מהירים שונים (ההאצה לא הייתה פי 2, אלא בערך פי 1.5).

איך לנסות את זה בעצמך

אם יש לך STM32F7-Discovery, אתה יכול להריץ Qt תחת Embox בעצמך. אתה יכול לקרוא איך זה נעשה אצלנו ויקי.

מסקנה

כתוצאה מכך, הצלחנו להשיק את Qt! מורכבות המשימה, לדעתנו, מוגזמת במקצת. באופן טבעי, אתה צריך לקחת בחשבון את הפרטים הספציפיים של מיקרו-בקרים ובאופן כללי להבין את הארכיטקטורה של מערכות מחשב. תוצאות האופטימיזציה מצביעות על העובדה הידועה שצוואר הבקבוק במערכת מחשוב אינו המעבד, אלא הזיכרון.

השנה נשתתף בפסטיבל TechTrain. שם נספר לכם ביתר פירוט ונראה את Qt, OpenCV על מיקרו-בקרים ושאר ההישגים שלנו.

מקור: www.habr.com