Qt for VxWorks

联络 Qt 公司了解更多信息: https://www.qt.io/contact-us/

支持的体系结构和 VxWorks 发行

  • Qt 6.7 is verified on VxWorks 23.09 Supported architecture is ARM-v7.

If you are interested in later Qt releases, please contact Qt professional services.

VxWorks 的要求

Qt Widgets Applications

  • POSIX 支持
  • C++17 support

Qt Quick 2 应用程序

All features which are required for Qt Widgets applications, and in addition the following:

  • 针对 OpenGL ES 2.0 的 GPUDEV (GPU 设备)

支持模块

Most essential Qt 模块 and some add-on modules are supported.

Supported Essential modules

Qt 模块 支持特征 注意事项
Qt Core
Qt GUI
Qt Network
Qt Qml
Qt Quick
Qt Quick Controls
Qt Quick Dialogs
Qt Quick Layouts
Qt Quick Test
Qt Test
Qt Widgets

Supported Add-Ons

Qt 附件 注意事项
Qt Concurrent
Qt GRPC/Protobuf
Qt Graphs
Qt Image Formats
Qt Multimedia
Qt Native Interfaces
Qt OpenGL
Qt Quick 3D
Qt Quick 编译器
Qt Quick Effects
Qt SQL
Qt SVG
Qt Virtual Keyboard

注意: You can explicitly exclude unsupported or unused modules from the build via the -skip <module> option when running the configure tool.

平台注意事项

With the release of Qt 5.0, Qt no longer contains its own window system implementation: QWS is no longer a supported platform. For single-process use cases, the Qt Platform Abstraction is a superior solution.

There is one plugin that is usable on VxWorks: EGLFS. The availability of this plugins depends on the configuration of Qt.

用于特定设备的配置

Building Qt for a given device requires a Qt6 installation for compilation host, a toolchain and a sysroot. Additionally, some devices require vendor specific adaptation code for EGL and OpenGL 2.0 support.

Before running configure and building Qt 6 it is required to open VxWorks Development Shell in command prompt.

  • Linux:
    cd <VxWorks installation directory>
    ./wrenv.sh -p vxworks
    							
  • Windows:
    cd <VxWorks installation directory>
    wrenv -p vxworks
    							

Below is an example configuration for the BD-SL-i.MX6. For most VxWorks boards the configure command looks very similar. By default, Qt 6 is configured to use shared libraries. To build Qt 6 statically, add -static option for configure.

./configure \
    -cmake-generator "Ninja" \
    -icu \
    -no-feature-timezone \
    -no-feature-vulkan \
    -platform vxworks-clang \
    -qt-host-path <path_to_qt6_host_installation_dir> \
    -sysroot <path_to_vxworks_vsb_dir>/fsl_imx6_<vsb_version>_VSB \
    -qpa "eglfs" \
    -DQT_QPA_EGLFS_INTEGRATION=eglfs_viv \
    -prefix /sd0:1/qt6rtp \
    -extprefix <path_to_host_dir>/qt6rtp \
    -nomake tools \
    -nomake examples
					

It is recommended to build Qt 6 using a shadow build 。见 Qt 配置选项 了解更多信息。

Building and Installing Qt 6

ninja
ninja install
					

用于 VxWorks 设备的平台插件

EGLFS

EGL is an interface between OpenGL and the native windowing system. Qt can use EGL for context and surface management. However, the API contains no platform specifics. The creation of a 本机窗口 (which will not necessarily be an actual window on the screen) must still be done by platform-specific means. Hence the need for the board or GPU specific adaptation code. Such adaptations are provided either as EGLFS hooks , a single source file compiled in to the platform plugin, or as dynamically loaded EGL device integration 插件。

EGLFS is a platform plugin for running Qt 6 applications on top of EGL and OpenGL ES 2.0 without an actual windowing system (like X11 or Wayland). In addition to Qt Quick 2 and native OpenGL applications it supports software-rendered windows (for example QWidget ) too. In the latter case the widgets' contents are rendered using the CPU into images which are then uploaded into textures and composited by the plugin.

This is the recommended plugin for modern VxWorks devices that include a GPU.

EGLFS forces the first top-level window (either a QWidget QQuickView ) to become fullscreen. This window is also chosen to be the root widget window into which all other top-level widgets (for example dialogs, popup menus or combobox dropdowns) are composited. This is necessary because with EGLFS there is always exactly one native window and EGL window surface, and these belong to the widget or window that is created first. This approach works well when there is a main window that exists for the entire lifetime of the application and all other widgets are either non top-levels or are created afterwards, once the main window is shown.

There are further restrictions for OpenGL-based windows. As of Qt 6.7, EGLFS supports a single, fullscreen GL window (for example, an OpenGL-based QWindow QQuickView or a QGLWidget). Opening additional OpenGL windows or mixing such windows with QWidget -based content is not supported and will terminate the application with an error message.

If necessary, EGLFS can be configured via environment variables:

  • QT_QPA_EGLFS_FB - Overrides the framebuffer device. The default is /dev/fb0 . On most embedded platforms this is not very relevant because the framebuffer is used only for querying settings like the display dimensions. On certain devices, however, this parameter provides the ability to specify which display to use in multiple display setups, similarly to the fb parameter in VxWorksFB.
  • QT_QPA_EGLFS_WIDTH and QT_QPA_EGLFS_HEIGHT - Contain the screen width and height in pixels. While EGLFS tries to determine the dimensions from the framebuffer device /dev/fb0 , this doesn't always work and manually specifying the sizes might become necessary.
  • QT_QPA_EGLFS_PHYSICAL_WIDTH and QT_QPA_EGLFS_PHYSICAL_HEIGHT - Physical screen width and height in millimeters. On platforms where the framebuffer device /dev/fb0 is not available or the query is not successful, the values are calculated based on a default DPI of 100. This variable can be used to override any such defaults.
  • QT_QPA_EGLFS_DEPTH - Overrides the color depth for the screen. On platforms where the framebuffer device /dev/fb0 is not available or the query is not successful, the default 32 is used. This variable can be used to override any such defaults. Note that this affects only the color depth value reported by QScreen . It has no connection to EGL configurations and the color depth used for OpenGL rendering.
  • QT_QPA_EGLFS_SWAPINTERVAL - By default a swap interval of 1 is requested. This enables synchronizing to the displays vertical refresh. The value can be overridden with this environment variable. For instance, passing 0 disables blocking on swap, resulting in running as fast as possible without any synchronization.
  • QT_QPA_EGLFS_FORCE888 - When set, the red, green and blue color channel sizes are ignored whenever creating a new context, window or offscreen surface. Instead, the plugin requests a configuration with 8 bits per channel. This can be helpful on devices where configurations with less than 32 or 24 bits per pixel are chosen by default but are known not to be suitable, for example, due to banding effects. Instead of changing all the applications, this variable provides an easier shortcut to force 24/32 bpp configurations for a given device.
  • QT_QPA_EGLFS_DEBUG - When set, some debugging information is printed on the debug output. For example, the input QSurfaceFormat and the properties of the chosen EGL configuration are printed whenever creating a new context. Together with Qt Quick's QSG_INFO variable, this can provide useful information for troubleshooting issues related to the EGL configuration.
  • QT_QPA_EGLFS_INTEGRATION - In addition to the compiled-in hooks , it is also possible to provide device or vendor-specific adaptation in the form of dynamically loaded plugins. This environment variable enforces a specific plugin. For example, setting it to eglfs_kms uses the KMS/DRM backend. This is only an option when no static, compiled-in hooks were specified in the device makespecs. In practice the traditional compiled-in hooks are rarely used, almost all backends are now migrated to plugins. The device makespecs still contain a relevant EGLFS_DEVICE_INTEGRATION entry: the name of the preferred backend for that particular device. This is optional, but very useful to avoid the need to set this environment variable in case there are more than one plugins present in the target system. In a desktop environment the KMS or the X11 backends are prioritized, depending on the presence of the DISPLAY 环境变量。

除了 QT_QPA_EGLFS_DEBUG , EGLFS also supports the more modern categorized logging system of Qt. The following logging categories are available:

  • qt.qpa.egldeviceintegration – Enables logging for dynamically loaded backends. Very useful to check what backend is in use.
  • qt.qpa.input – Enables debug output from the evdev input handler. Very useful to check if a given input device was correctly recognized and opened.

运行 Qt 应用程序

The following example shows how to start an application when Qt 6 is built using shared libraries. With a statically built Qt 6, there is no need to use the LD_LIBRARY_PATH environment variable. This variable is only needed to point the location of VxWorks shared libraries (for example libc and OpenGL ES 2.0). It is not needed for Qt 6 static libraries.

putenv "LD_LIBRARY_PATH=/sd0:1/lib"
cd "/sd0:1"
rtpSp("<Qt6_app>", 200, 0x100000, 0, 0x01000000)
					

局限性

视频内存

Systems with a fixed amount of dedicated video memory may need extra care before running Qt application based on Qt Quick or classes like QOpenGLWidget . The default setting may be insufficient for such applications, especially when they are displayed on a high resolution (for example, full HD) screen. In this case they might start failing in unexpected ways. It is therefore recommended to ensure that there is at least 128 MB of GPU memory available. For systems that do not have a fixed amount of memory reserved for the GPU this is not an issue.