Qt Quick Ultralite on FreeRTOS Prerequisites

C

Qt Quick Ultralite overview

Qt Quick Ultralite brings the key graphical user interface features of Qt to resource-constrained embedded systems powered by microcontrollers (MCU). It provides a rich QML API set for building fluid GUIs, and an efficient graphics engine to render Qt Quick-based graphical user interfaces (GUI).

Qt Quick Ultralite is aware of the resource constraints on the MCU platforms, such as memory footprint and CPU cycles. It enables your application to perform optimally with the available resources on these MCU platforms.

Key features

  • A graphics engine that is optimized for low memory footprint.
  • Tools to generate efficient C++ code based on the QML code and graphical resources.
  • Conforms to the C++14 standard.
  • Supports some of the most popular microcontroller-based hardware.
  • Supports baremetal or MCU operating system such as FreeRTOS.
  • Ultra-light UI controls to build fluid GUIs using QML.
  • Custom styling for graphic elements.
  • Internationalization support to enable catering to various regions.
  • Offers better developer experience with the Qt Creator IDE and Qt Design Studio.
  • Good documentation, examples, and tutorials that gets you on board quickly.

Minimum hardware requirements

Qt Quick Ultralite includes a set of platform implementations for evaluation kits of popular MCU platforms. See Supported Target Boards and Development Hosts for a list of those platforms.

You can adapt Qt Quick Ultralite to any modern MCU platform that is capable of driving a display, and meets the following requirements:

  • Microcontroller/processor: Cortex M4, M33, or higher. A Floating Point Unit (FPU) is optional, but improves performance considerably.
  • RAM (internal/external):
    • Static RAM: 20 Kb for minimal applications and 200 Kb or more for typical applications.
    • Stack: 2-12 Kb.
    • Heap: 20 Kb.

    You also need sufficient RAM for framebuffer, depending on the display size, color depth, and the framebuffer strategy (single or double buffering).

  • Flash/ROM: 500 KB or more.
  • GPU/hardware acceleration is optional, but it a must have to achieve more than 20 FPS framerate for animations.
  • Display interface: RGB, MIPI-DSI, or LVDS for high resolution and framerate SPI, or Parallel for low resolution and/or low framerate.
  • Graphics driver that supports one of the pixel formats that Qt Quick Ultralite supports.
  • C++14 compatible compiler.

Note: The maximum resolution and frame rate you get varies depending on the display interface.

Hardware acceleration

Qt Quick Ultralite uses hardware acceleration on platforms that support it, otherwise it uses the CPU fallback to render graphics. Even though hardware acceleration is preferred to run animations at a framerate above 20 fps, it is not a strict requirement.

The following graphical operations are hardware-accelerated depending on the MCU platform:

  • Image drawing
  • Text drawing
  • Rectangle drawing
  • 2D path drawing
  • 2D and 2.5D transformations on images, texts, rectangles and paths
  • Blending (images, texts, rectangle, paths, layers)

Qt Quick Ultralite comes with hardware-accelerated graphics implementations for the following drivers:

  • CyGfx (Infineon Traveo II)
  • Dave2D (Renesas RA6)
  • DaveHD (Renesas RH850)
  • PxP (NXP i.MX RT)
  • VGLite (NXP i.MX RT1170)
  • Chrom-ART (STM32)

Memory footprint

RAM usage depends on the size and color depth of the display, the Qt Quick Ultralite features used, and the number of GUI elements in the application.

A typical application may have the following memory footprint, depending on the resolution and color depth combination that it use:

  • Low resolution and color depth: at least 150-250 Kb
  • Medium resolution and color depth: at least 400-700 Kb
  • High resolution and color depth: 2 Mb or more

A Qt Quick Ultralite application's Flash or ROM usage depends on the number of images and fonts it uses. In most cases, 500 Kb to 10 Mb of Flash or ROM is sufficient.

Compatibility with Qt Quick

Since version 1.3, the QML subset offered by Qt Quick Ultralite is source-compatible with Qt Quick. This enables you to run the Qt for MCUs application using Qt Quick. It also means that you can reuse existing code that's based on Qt Quick, Qt Quick Controls, or Qt Quick Timeline, in a Qt for MCUs application.

Although most of the Qt Quick Ultralite code works with Qt Quick, there are a few limitations that you should be aware of. The following topics cover the differences between the two QML typesets and helps you use them efficiently:

Qt Quick Ultralite on FreeRTOS Prerequisites

Available under certain Qt licenses.
Find out more.