Qt ਨੂੰ STM32 'ਤੇ ਪੋਰਟ ਕਰਨਾ

ਨਮਸਕਾਰ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਹਾਂ ਐਮਬਾਕਸ Qt ਨੂੰ STM32F7-ਡਿਸਕਵਰੀ 'ਤੇ ਲਾਂਚ ਕੀਤਾ ਹੈ ਅਤੇ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਨਾ ਚਾਹਾਂਗਾ। ਪਹਿਲਾਂ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਹੈ ਕਿ ਅਸੀਂ ਕਿਵੇਂ ਲਾਂਚ ਕਰਨ ਵਿੱਚ ਕਾਮਯਾਬ ਹੋਏ ਓਪਨਸੀਵੀ.

Qt ਇੱਕ ਕਰਾਸ-ਪਲੇਟਫਾਰਮ ਫਰੇਮਵਰਕ ਹੈ ਜਿਸ ਵਿੱਚ ਨਾ ਸਿਰਫ਼ ਗ੍ਰਾਫਿਕਲ ਹਿੱਸੇ ਸ਼ਾਮਲ ਹਨ, ਸਗੋਂ QtNetwork, ਡਾਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕਲਾਸਾਂ ਦਾ ਇੱਕ ਸੈੱਟ, ਆਟੋਮੇਸ਼ਨ ਲਈ Qt (IoT ਲਾਗੂ ਕਰਨ ਸਮੇਤ) ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਸ਼ਾਮਲ ਹੈ। Qt ਟੀਮ ਏਮਬੈਡਡ ਸਿਸਟਮਾਂ ਵਿੱਚ Qt ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਸਰਗਰਮ ਰਹੀ ਹੈ, ਇਸਲਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕਾਫ਼ੀ ਸੰਰਚਨਾਯੋਗ ਹਨ। ਹਾਲਾਂਕਿ, ਹਾਲ ਹੀ ਵਿੱਚ, ਕੁਝ ਲੋਕਾਂ ਨੇ Qt ਨੂੰ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰਸ ਨੂੰ ਪੋਰਟ ਕਰਨ ਬਾਰੇ ਸੋਚਿਆ, ਸ਼ਾਇਦ ਕਿਉਂਕਿ ਅਜਿਹਾ ਕੰਮ ਮੁਸ਼ਕਲ ਲੱਗਦਾ ਹੈ - Qt ਵੱਡਾ ਹੈ, MCU ਛੋਟੇ ਹਨ।

ਦੂਜੇ ਪਾਸੇ, ਇਸ ਸਮੇਂ ਮਲਟੀਮੀਡੀਆ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਹਨ ਅਤੇ ਪਹਿਲੇ ਪੇਂਟਿਅਮ ਤੋਂ ਉੱਤਮ ਹਨ। ਲਗਭਗ ਇੱਕ ਸਾਲ ਪਹਿਲਾਂ, Qt ਬਲੌਗ ਪ੍ਰਗਟ ਹੋਇਆ ਸੀ ਪੋਸਟ. ਡਿਵੈਲਪਰਾਂ ਨੇ RTEMS OS ਲਈ Qt ਦਾ ਇੱਕ ਪੋਰਟ ਬਣਾਇਆ, ਅਤੇ stm32f7 ਨੂੰ ਚਲਾਉਣ ਵਾਲੇ ਕਈ ਬੋਰਡਾਂ 'ਤੇ ਵਿਜੇਟਸ ਨਾਲ ਉਦਾਹਰਨਾਂ ਲਾਂਚ ਕੀਤੀਆਂ। ਇਹ ਸਾਡੀ ਦਿਲਚਸਪੀ ਸੀ. ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਸੀ, ਅਤੇ ਡਿਵੈਲਪਰ ਖੁਦ ਇਸ ਬਾਰੇ ਲਿਖਦੇ ਹਨ, ਕਿ Qt STM32F7-ਡਿਸਕਵਰੀ 'ਤੇ ਹੌਲੀ ਹੈ. ਅਸੀਂ ਸੋਚ ਰਹੇ ਸੀ ਕਿ ਕੀ ਅਸੀਂ Embox ਦੇ ਅਧੀਨ Qt ਚਲਾ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਨਾ ਸਿਰਫ਼ ਇੱਕ ਵਿਜੇਟ ਖਿੱਚ ਸਕਦੇ ਹਾਂ, ਪਰ ਇੱਕ ਐਨੀਮੇਸ਼ਨ ਚਲਾ ਸਕਦੇ ਹਾਂ।

Qt 4.8 ਨੂੰ ਲੰਬੇ ਸਮੇਂ ਤੋਂ Embox ਵਿੱਚ ਪੋਰਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਇਸਨੂੰ ਇਸ 'ਤੇ ਅਜ਼ਮਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਅਸੀਂ ਮੂਵਬਲੌਕਸ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚੁਣਿਆ - ਸਪ੍ਰਿੰਗੀ ਐਨੀਮੇਸ਼ਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ।

QEMU 'ਤੇ Qt ਮੂਵਬਲੌਕਸ

ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਐਨੀਮੇਸ਼ਨ ਦੇ ਸਮਰਥਨ ਲਈ ਲੋੜੀਂਦੇ ਭਾਗਾਂ ਦੇ ਘੱਟੋ-ਘੱਟ ਸਮੂਹ ਦੇ ਨਾਲ, ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ ਤਾਂ Qt ਨੂੰ ਸੰਰਚਿਤ ਕਰਦੇ ਹਾਂ। ਇਸਦੇ ਲਈ ਇੱਕ ਵਿਕਲਪ ਹੈ “-qconfig minimal,small,medium...”। ਇਹ Qt ਤੋਂ ਇੱਕ ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਮੈਕਰੋ ਨਾਲ ਜੋੜਦਾ ਹੈ - ਕੀ ਸਮਰੱਥ ਕਰਨਾ ਹੈ / ਕੀ ਅਯੋਗ ਕਰਨਾ ਹੈ. ਇਸ ਵਿਕਲਪ ਤੋਂ ਬਾਅਦ, ਜੇਕਰ ਅਸੀਂ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਨੂੰ ਅਯੋਗ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ ਸੰਰਚਨਾ ਵਿੱਚ ਹੋਰ ਫਲੈਗ ਜੋੜਦੇ ਹਾਂ। ਇੱਥੇ ਸਾਡੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਸੰਰਚਨਾ.

Qt ਦੇ ਕੰਮ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ OS ਅਨੁਕੂਲਤਾ ਪਰਤ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇੱਕ ਤਰੀਕਾ QPA (Qt ਪਲੇਟਫਾਰਮ ਐਬਸਟਰੈਕਸ਼ਨ) ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਹੈ। ਅਸੀਂ Qt ਵਿੱਚ ਸ਼ਾਮਲ ਤਿਆਰ-ਕੀਤੀ fb_base ਪਲੱਗਇਨ ਨੂੰ ਇੱਕ ਅਧਾਰ ਵਜੋਂ ਲਿਆ, ਜਿਸ ਦੇ ਅਧਾਰ 'ਤੇ ਲੀਨਕਸ ਲਈ 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 ਦੀ ਮੁੱਖ ਮੈਮੋਰੀ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦਾ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਓਪਨਸੀਵੀ ਬਾਰੇ ਸਾਡੇ ਦੂਜੇ ਲੇਖ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਲਿਖਿਆ ਹੈ, ਇਸ ਬੋਰਡ ਵਿੱਚ ਹੈ:

• 1 MB ROM
• 320 KB ਰੈਮ
• 8 MB SDRAM
• 16 MB QSPI

ਕਿਉਂਕਿ QSPI ਤੋਂ ਕੋਡ ਚਲਾਉਣ ਲਈ ਸਮਰਥਨ ਪਹਿਲਾਂ ਹੀ OpenCV ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਹੈ, ਅਸੀਂ QSPI ਵਿੱਚ ਪੂਰੇ Embox c Qt ਚਿੱਤਰ ਨੂੰ ਲੋਡ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਅਤੇ ਜਲਦੀ, ਸਭ ਕੁਝ QSPI ਤੋਂ ਲਗਭਗ ਤੁਰੰਤ ਸ਼ੁਰੂ ਹੋਇਆ! ਪਰ ਜਿਵੇਂ ਕਿ ਓਪਨਸੀਵੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ ਪਤਾ ਚਲਿਆ ਕਿ ਇਹ ਬਹੁਤ ਹੌਲੀ ਹੌਲੀ ਕੰਮ ਕਰਦਾ ਹੈ.

ਇਸ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ - ਪਹਿਲਾਂ ਅਸੀਂ ਚਿੱਤਰ ਨੂੰ QSPI ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਇਸਨੂੰ SDRAM ਵਿੱਚ ਲੋਡ ਕਰਦੇ ਹਾਂ ਅਤੇ ਉੱਥੋਂ ਚਲਾਉਂਦੇ ਹਾਂ। SDRAM ਤੋਂ ਇਹ ਥੋੜਾ ਤੇਜ਼ ਹੋ ਗਿਆ, ਪਰ ਅਜੇ ਵੀ QEMU ਤੋਂ ਬਹੁਤ ਦੂਰ ਹੈ।

ਅੱਗੇ, ਇੱਕ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਇੱਕ ਵਿਚਾਰ ਸੀ - ਆਖਰਕਾਰ, Qt ਐਨੀਮੇਸ਼ਨ ਵਿੱਚ ਵਰਗਾਂ ਦੇ ਕੋਆਰਡੀਨੇਟਸ ਦੀ ਕੁਝ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਪਰ ਇੱਥੇ ਸਾਨੂੰ ਕੋਈ ਪ੍ਰਤੱਖ ਪ੍ਰਵੇਗ ਨਹੀਂ ਮਿਲਿਆ, ਹਾਲਾਂਕਿ ਵਿੱਚ ਲੇਖ Qt ਡਿਵੈਲਪਰਾਂ ਨੇ ਦਾਅਵਾ ਕੀਤਾ ਕਿ FPU ਟੱਚਸਕ੍ਰੀਨ 'ਤੇ "ਡਰੈਗਿੰਗ ਐਨੀਮੇਸ਼ਨ" ਲਈ ਗਤੀ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਵਾਧਾ ਦਿੰਦਾ ਹੈ। ਮੂਵਬਲੌਕਸ ਵਿੱਚ ਬਹੁਤ ਘੱਟ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਕੈਲਕੂਲੇਸ਼ਨ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਇਹ ਖਾਸ ਉਦਾਹਰਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਵਿਚਾਰ ਫਰੇਮਬਫਰ ਨੂੰ SDRAM ਤੋਂ ਅੰਦਰੂਨੀ ਮੈਮੋਰੀ ਵਿੱਚ ਲਿਜਾਣਾ ਸੀ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਕ੍ਰੀਨ ਦੇ ਮਾਪ 480x272 ਨਹੀਂ, ਸਗੋਂ 272x272 ਬਣਾਏ ਹਨ। ਅਸੀਂ ਰੰਗ ਦੀ ਡੂੰਘਾਈ ਨੂੰ A8R8G8B8 ਤੋਂ R5G6B5 ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਪਿਕਸਲ ਦਾ ਆਕਾਰ 4 ਤੋਂ 2 ਬਾਈਟ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਫਰੇਮਬਫਰ ਦਾ ਆਕਾਰ 272 * 272 * 2 = 147968 ਬਾਈਟ ਹੈ। ਇਸ ਨੇ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਵੇਗ ਦਿੱਤਾ, ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵੱਧ ਧਿਆਨ ਦੇਣ ਯੋਗ, ਐਨੀਮੇਸ਼ਨ ਲਗਭਗ ਨਿਰਵਿਘਨ ਬਣ ਗਈ।

ਨਵੀਨਤਮ ਓਪਟੀਮਾਈਜੇਸ਼ਨ RAM ਤੋਂ Embox ਕੋਡ ਅਤੇ SDRAM ਤੋਂ Qt ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਲਈ ਸੀ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਪਹਿਲਾਂ, ਆਮ ਵਾਂਗ, ਸਥਿਰ ਤੌਰ 'ਤੇ Embox ਨੂੰ Qt ਨਾਲ ਜੋੜਦੇ ਹਾਂ, ਪਰ ਅਸੀਂ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਟੈਕਸਟ, ਰੋਡਾਟਾ, ਡੇਟਾ ਅਤੇ 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))

ROM ਤੋਂ Embox ਕੋਡ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕਰਕੇ, ਸਾਨੂੰ ਇੱਕ ਧਿਆਨ ਦੇਣ ਯੋਗ ਪ੍ਰਵੇਗ ਵੀ ਮਿਲਿਆ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਐਨੀਮੇਸ਼ਨ ਕਾਫ਼ੀ ਨਿਰਵਿਘਨ ਨਿਕਲਿਆ:

ਬਹੁਤ ਹੀ ਅੰਤ ਵਿੱਚ, ਲੇਖ ਨੂੰ ਤਿਆਰ ਕਰਨ ਅਤੇ ਵੱਖ-ਵੱਖ Embox ਸੰਰਚਨਾਵਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਪਤਾ ਚਲਿਆ ਕਿ Qt ਮੂਵਬਲੌਕਸ SDRAM ਵਿੱਚ ਇੱਕ ਫਰੇਮਬਫਰ ਦੇ ਨਾਲ QSPI ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਰੁਕਾਵਟ ਬਿਲਕੁਲ ਫਰੇਮਬਫਰ ਦਾ ਆਕਾਰ ਸੀ! ਜ਼ਾਹਰਾ ਤੌਰ 'ਤੇ, ਸ਼ੁਰੂਆਤੀ "ਸਲਾਈਡਸ਼ੋਅ" ਨੂੰ ਦੂਰ ਕਰਨ ਲਈ, ਫਰੇਮਬਫਰ ਦੇ ਆਕਾਰ ਵਿੱਚ ਮਾਮੂਲੀ ਕਮੀ ਦੇ ਕਾਰਨ ਇੱਕ 2-ਗੁਣਾ ਪ੍ਰਵੇਗ ਕਾਫ਼ੀ ਸੀ। ਪਰ ਸਿਰਫ ਐਮਬਾਕਸ ਕੋਡ ਨੂੰ ਵੱਖ-ਵੱਖ ਤੇਜ਼ ਯਾਦਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਕੇ ਅਜਿਹਾ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਸੀ (ਪ੍ਰਵੇਗ 2 ਨਹੀਂ ਸੀ, ਪਰ ਲਗਭਗ 1.5 ਗੁਣਾ ਸੀ)।

ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਕਿਵੇਂ ਅਜ਼ਮਾਉਣਾ ਹੈ

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ STM32F7-ਡਿਸਕਵਰੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ Embox ਦੇ ਹੇਠਾਂ Qt ਚਲਾ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਸਾਡੇ 'ਤੇ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਵਿਕੀ.

ਸਿੱਟਾ

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ Qt ਨੂੰ ਲਾਂਚ ਕਰਨ ਵਿੱਚ ਕਾਮਯਾਬ ਰਹੇ! ਕੰਮ ਦੀ ਗੁੰਝਲਤਾ, ਸਾਡੀ ਰਾਏ ਵਿੱਚ, ਕੁਝ ਹੱਦ ਤੱਕ ਅਤਿਕਥਨੀ ਹੈ. ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਕੰਪਿਊਟਰ ਪ੍ਰਣਾਲੀਆਂ ਦੇ ਢਾਂਚੇ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਨਤੀਜੇ ਜਾਣੇ-ਪਛਾਣੇ ਤੱਥ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ ਕਿ ਇੱਕ ਕੰਪਿਊਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਰੁਕਾਵਟ ਪ੍ਰੋਸੈਸਰ ਨਹੀਂ ਹੈ, ਪਰ ਮੈਮੋਰੀ ਹੈ।

ਇਸ ਸਾਲ ਅਸੀਂ ਤਿਉਹਾਰ ਵਿੱਚ ਹਿੱਸਾ ਲਵਾਂਗੇ TechTrain. ਉੱਥੇ ਅਸੀਂ ਤੁਹਾਨੂੰ ਵਧੇਰੇ ਵਿਸਤਾਰ ਵਿੱਚ ਦੱਸਾਂਗੇ ਅਤੇ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ 'ਤੇ Qt, OpenCV ਅਤੇ ਸਾਡੀਆਂ ਹੋਰ ਪ੍ਰਾਪਤੀਆਂ ਦਿਖਾਵਾਂਗੇ।

ਸਰੋਤ: www.habr.com