ಕ್ಯೂಟಿಯನ್ನು STM32 ಗೆ ಪೋರ್ಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಶುಭ ಅಪರಾಹ್ನ ನಾವು ಯೋಜನೆಯಲ್ಲಿದ್ದೇವೆ ಎಂಬಾಕ್ಸ್ STM32F7-ಡಿಸ್ಕವರಿಯಲ್ಲಿ Qt ಅನ್ನು ಪ್ರಾರಂಭಿಸಿತು ಮತ್ತು ಅದರ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಬಯಸುತ್ತೇನೆ. ಮೊದಲು, ನಾವು ಹೇಗೆ ಪ್ರಾರಂಭಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ನಾವು ಈಗಾಗಲೇ ಹೇಳಿದ್ದೇವೆ ಓಪನ್‌ಸಿವಿ.

Qt ಎನ್ನುವುದು ಗ್ರಾಫಿಕಲ್ ಘಟಕಗಳನ್ನು ಮಾತ್ರವಲ್ಲದೆ QtNetwork, ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ತರಗತಿಗಳ ಒಂದು ಸೆಟ್, ಆಟೊಮೇಷನ್‌ಗಾಗಿ Qt (IoT ಅನುಷ್ಠಾನವನ್ನು ಒಳಗೊಂಡಂತೆ) ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕ್ರಾಸ್-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದೆ. Qt ತಂಡವು ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ Qt ಅನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ಪೂರ್ವಭಾವಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ, ಆದ್ದರಿಂದ ಲೈಬ್ರರಿಗಳು ಸಾಕಷ್ಟು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಇತ್ತೀಚಿನವರೆಗೂ, ಕೆಲವು ಜನರು ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ಗಳಿಗೆ Qt ಅನ್ನು ಪೋರ್ಟ್ ಮಾಡುವ ಬಗ್ಗೆ ಯೋಚಿಸಿದ್ದಾರೆ, ಬಹುಶಃ ಅಂತಹ ಕಾರ್ಯವು ಕಷ್ಟಕರವೆಂದು ತೋರುತ್ತದೆ - Qt ದೊಡ್ಡದಾಗಿದೆ, MCU ಗಳು ಚಿಕ್ಕದಾಗಿದೆ.

ಮತ್ತೊಂದೆಡೆ, ಈ ಸಮಯದಲ್ಲಿ ಮಲ್ಟಿಮೀಡಿಯಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ಗಳು ಮತ್ತು ಮೊದಲ ಪೆಂಟಿಯಮ್‌ಗಳಿಗಿಂತ ಉತ್ತಮವಾಗಿವೆ. ಸುಮಾರು ಒಂದು ವರ್ಷದ ಹಿಂದೆ, ಕ್ಯೂಟಿ ಬ್ಲಾಗ್ ಕಾಣಿಸಿಕೊಂಡಿತು ಪೋಸ್ಟ್. ಡೆವಲಪರ್‌ಗಳು RTEMS OS ಗಾಗಿ Qt ನ ಪೋರ್ಟ್ ಅನ್ನು ತಯಾರಿಸಿದರು ಮತ್ತು stm32f7 ಚಾಲನೆಯಲ್ಲಿರುವ ಹಲವಾರು ಬೋರ್ಡ್‌ಗಳಲ್ಲಿ ವಿಜೆಟ್‌ಗಳೊಂದಿಗೆ ಉದಾಹರಣೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದರು. ಇದು ನಮಗೆ ಆಸಕ್ತಿಯನ್ನುಂಟುಮಾಡಿದೆ. ಇದು ಗಮನಾರ್ಹವಾಗಿದೆ, ಮತ್ತು ಡೆವಲಪರ್‌ಗಳು ಸ್ವತಃ ಅದರ ಬಗ್ಗೆ ಬರೆಯುತ್ತಾರೆ, STM32F7-ಡಿಸ್ಕವರಿಯಲ್ಲಿ Qt ನಿಧಾನವಾಗಿದೆ. ನಾವು ಎಂಬಾಕ್ಸ್ ಅಡಿಯಲ್ಲಿ ಕ್ಯೂಟಿ ರನ್ ಮಾಡಬಹುದೇ ಎಂದು ನಾವು ಆಶ್ಚರ್ಯ ಪಡುತ್ತಿದ್ದೆವು, ಮತ್ತು ಕೇವಲ ವಿಜೆಟ್ ಅನ್ನು ಸೆಳೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಅನಿಮೇಷನ್ ಅನ್ನು ರನ್ ಮಾಡಬಹುದೇ ಎಂದು.

Qt 4.8 ಅನ್ನು ದೀರ್ಘಕಾಲದವರೆಗೆ ಎಂಬಾಕ್ಸ್‌ಗೆ ಪೋರ್ಟ್ ಮಾಡಲಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಪ್ರಯತ್ನಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ನಾವು ಮೂವ್‌ಬ್ಲಾಕ್ಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಆರಿಸಿದ್ದೇವೆ - ಸ್ಪ್ರಿಂಗ್ ಅನಿಮೇಷನ್‌ನ ಉದಾಹರಣೆ.

QEMU ನಲ್ಲಿ Qt ಮೂವ್‌ಬ್ಲಾಕ್‌ಗಳು

ಪ್ರಾರಂಭಿಸಲು, ನಾವು Qt ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ, ಸಾಧ್ಯವಾದರೆ, ಅನಿಮೇಷನ್ ಅನ್ನು ಬೆಂಬಲಿಸಲು ಅಗತ್ಯವಿರುವ ಕನಿಷ್ಠ ಘಟಕಗಳೊಂದಿಗೆ. ಇದಕ್ಕಾಗಿ “-qconfig minimal,small,medium...” ಎಂಬ ಆಯ್ಕೆ ಇದೆ. ಇದು ಅನೇಕ ಮ್ಯಾಕ್ರೋಗಳೊಂದಿಗೆ Qt ನಿಂದ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುತ್ತದೆ - ಯಾವುದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು / ಯಾವುದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬೇಕು. ಈ ಆಯ್ಕೆಯ ನಂತರ, ನಾವು ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು ಬಯಸಿದರೆ ನಾವು ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಇತರ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ನಮ್ಮ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ ಸಂರಚನೆ.

Qt ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ನೀವು OS ಹೊಂದಾಣಿಕೆಯ ಲೇಯರ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ. QPA (Qt ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅಮೂರ್ತತೆ) ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. 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 MB ROM
• 320 KB RAM
• 8 MB SDRAM
• 16 MB QSPI

QSPI ಯಿಂದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬೆಂಬಲವನ್ನು ಈಗಾಗಲೇ OpenCV ಗೆ ಸೇರಿಸಿರುವುದರಿಂದ, ನಾವು ಸಂಪೂರ್ಣ ಎಂಬಾಕ್ಸ್ c Qt ಚಿತ್ರವನ್ನು QSPI ಗೆ ಲೋಡ್ ಮಾಡುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಮತ್ತು ಹುರ್ರೇ, ಎಲ್ಲವೂ QSPI ನಿಂದ ತಕ್ಷಣವೇ ಪ್ರಾರಂಭವಾಯಿತು! ಆದರೆ OpenCV ಯಂತೆಯೇ, ಅದು ತುಂಬಾ ನಿಧಾನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ನಾವು ಇದನ್ನು ಈ ರೀತಿ ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ - ಮೊದಲು ನಾವು ಚಿತ್ರವನ್ನು QSPI ಗೆ ನಕಲಿಸುತ್ತೇವೆ, ನಂತರ ಅದನ್ನು SDRAM ಗೆ ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಅಲ್ಲಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಿ. SDRAM ನಿಂದ ಇದು ಸ್ವಲ್ಪ ವೇಗವಾಯಿತು, ಆದರೆ ಇನ್ನೂ QEMU ನಿಂದ ದೂರವಿದೆ.

ಮುಂದೆ, ತೇಲುವ ಬಿಂದುವನ್ನು ಸೇರಿಸಲು ಒಂದು ಕಲ್ಪನೆ ಇತ್ತು - ಎಲ್ಲಾ ನಂತರ, ಕ್ಯೂಟಿ ಅನಿಮೇಷನ್‌ನಲ್ಲಿ ಚೌಕಗಳ ನಿರ್ದೇಶಾಂಕಗಳ ಕೆಲವು ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡುತ್ತದೆ. ನಾವು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ, ಆದರೆ ಇಲ್ಲಿ ನಾವು ಯಾವುದೇ ಗೋಚರ ವೇಗವರ್ಧನೆಯನ್ನು ಪಡೆಯಲಿಲ್ಲ, ಆದರೂ ಲೇಖನ ಟಚ್‌ಸ್ಕ್ರೀನ್‌ನಲ್ಲಿ "ಡ್ರ್ಯಾಗ್ ಅನಿಮೇಷನ್" ವೇಗದಲ್ಲಿ FPU ಗಮನಾರ್ಹ ಹೆಚ್ಚಳವನ್ನು ನೀಡುತ್ತದೆ ಎಂದು Qt ಡೆವಲಪರ್‌ಗಳು ಹೇಳಿಕೊಂಡಿದ್ದಾರೆ. ಮೂವ್‌ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಲೆಕ್ಕಾಚಾರಗಳು ಇರಬಹುದು, ಮತ್ತು ಇದು ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.

ಫ್ರೇಮ್‌ಬಫರ್ ಅನ್ನು SDRAM ನಿಂದ ಆಂತರಿಕ ಮೆಮೊರಿಗೆ ಸರಿಸಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಉಪಾಯವಾಗಿದೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಪರದೆಯ ಆಯಾಮಗಳನ್ನು 480x272 ಅಲ್ಲ, ಆದರೆ 272x272 ಮಾಡಿದ್ದೇವೆ. ನಾವು A8R8G8B8 ನಿಂದ R5G6B5 ಗೆ ಬಣ್ಣದ ಆಳವನ್ನು ಕಡಿಮೆಗೊಳಿಸಿದ್ದೇವೆ, ಹೀಗಾಗಿ ಒಂದು ಪಿಕ್ಸೆಲ್‌ನ ಗಾತ್ರವನ್ನು 4 ರಿಂದ 2 ಬೈಟ್‌ಗಳಿಗೆ ಕಡಿಮೆ ಮಾಡಿದ್ದೇವೆ. ಪರಿಣಾಮವಾಗಿ ಫ್ರೇಮ್‌ಬಫರ್ ಗಾತ್ರವು 272 * 272 * 2 = 147968 ಬೈಟ್‌ಗಳು. ಇದು ಗಮನಾರ್ಹವಾದ ವೇಗವರ್ಧನೆಯನ್ನು ನೀಡಿತು, ಬಹುಶಃ ಅತ್ಯಂತ ಗಮನಾರ್ಹವಾಗಿ, ಅನಿಮೇಷನ್ ಬಹುತೇಕ ಸುಗಮವಾಯಿತು.

ಇತ್ತೀಚಿನ ಆಪ್ಟಿಮೈಸೇಶನ್ RAM ನಿಂದ ಎಂಬಾಕ್ಸ್ ಕೋಡ್ ಮತ್ತು SDRAM ನಿಂದ Qt ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಮೊದಲು, ಎಂದಿನಂತೆ, ಕ್ಯೂಟಿ ಜೊತೆಗೆ ಎಂಬಾಕ್ಸ್ ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಲಿಂಕ್ ಮಾಡುತ್ತೇವೆ, ಆದರೆ ನಾವು ಅದನ್ನು 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 ನಿಂದ ಎಂಬಾಕ್ಸ್ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, ನಾವು ಗಮನಾರ್ಹ ವೇಗವರ್ಧನೆಯನ್ನು ಸಹ ಸ್ವೀಕರಿಸಿದ್ದೇವೆ. ಪರಿಣಾಮವಾಗಿ, ಅನಿಮೇಷನ್ ಸಾಕಷ್ಟು ಮೃದುವಾಗಿ ಹೊರಹೊಮ್ಮಿತು:

ಕೊನೆಯಲ್ಲಿ, ಲೇಖನವನ್ನು ಸಿದ್ಧಪಡಿಸುವಾಗ ಮತ್ತು ವಿಭಿನ್ನ ಎಂಬಾಕ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಪ್ರಯತ್ನಿಸುವಾಗ, Qt ಮೂವ್‌ಬ್ಲಾಕ್‌ಗಳು SDRAM ನಲ್ಲಿ ಫ್ರೇಮ್‌ಬಫರ್‌ನೊಂದಿಗೆ QSPI ನಿಂದ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಅಡಚಣೆಯು ನಿಖರವಾಗಿ ಫ್ರೇಮ್‌ಬಫರ್‌ನ ಗಾತ್ರವಾಗಿದೆ! ಸ್ಪಷ್ಟವಾಗಿ, ಆರಂಭಿಕ "ಸ್ಲೈಡ್‌ಶೋ" ಅನ್ನು ಜಯಿಸಲು, ಫ್ರೇಮ್‌ಬಫರ್‌ನ ಗಾತ್ರದಲ್ಲಿ ನೀರಸ ಕಡಿತದ ಕಾರಣ 2-ಪಟ್ಟು ವೇಗವರ್ಧನೆಯು ಸಾಕಾಗುತ್ತದೆ. ಆದರೆ ಎಂಬಾಕ್ಸ್ ಕೋಡ್ ಅನ್ನು ವಿವಿಧ ವೇಗದ ನೆನಪುಗಳಿಗೆ ವರ್ಗಾಯಿಸುವ ಮೂಲಕ ಅಂತಹ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ (ವೇಗವು 2 ಅಲ್ಲ, ಆದರೆ ಸುಮಾರು 1.5 ಬಾರಿ).

ಅದನ್ನು ನೀವೇ ಪ್ರಯತ್ನಿಸುವುದು ಹೇಗೆ

ನೀವು STM32F7-ಡಿಸ್ಕವರಿ ಹೊಂದಿದ್ದರೆ, ನೀವೇ ಎಂಬಾಕ್ಸ್ ಅಡಿಯಲ್ಲಿ Qt ಅನ್ನು ಚಲಾಯಿಸಬಹುದು. ನಮ್ಮಲ್ಲಿ ಇದನ್ನು ಹೇಗೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ಓದಬಹುದು ವಿಕಿ.

ತೀರ್ಮಾನಕ್ಕೆ

ಪರಿಣಾಮವಾಗಿ, ನಾವು Qt ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇವೆ! ಕಾರ್ಯದ ಸಂಕೀರ್ಣತೆ, ನಮ್ಮ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಉತ್ಪ್ರೇಕ್ಷಿತವಾಗಿದೆ. ನೈಸರ್ಗಿಕವಾಗಿ, ನೀವು ಮೈಕ್ರೊಕಂಟ್ರೋಲರ್ಗಳ ನಿಶ್ಚಿತಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಕಂಪ್ಯೂಟರ್ ಸಿಸ್ಟಮ್ಗಳ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಆಪ್ಟಿಮೈಸೇಶನ್ ಫಲಿತಾಂಶಗಳು ಕಂಪ್ಯೂಟಿಂಗ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿನ ಅಡಚಣೆಯು ಪ್ರೊಸೆಸರ್ ಅಲ್ಲ, ಆದರೆ ಮೆಮೊರಿ ಎಂದು ತಿಳಿದಿರುವ ಸತ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಈ ವರ್ಷ ನಾವು ಉತ್ಸವದಲ್ಲಿ ಭಾಗವಹಿಸುತ್ತೇವೆ ಟೆಕ್ ಟ್ರೈನ್. ಅಲ್ಲಿ ನಾವು ನಿಮಗೆ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಹೇಳುತ್ತೇವೆ ಮತ್ತು ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ಗಳಲ್ಲಿ ಕ್ಯೂಟಿ, ಓಪನ್‌ಸಿವಿ ಮತ್ತು ನಮ್ಮ ಇತರ ಸಾಧನೆಗಳನ್ನು ತೋರಿಸುತ್ತೇವೆ.

ಮೂಲ: www.habr.com