Qt für VxWorks

Kontaktieren Sie The Qt Company für weitere Informationen: https://www.qt.io/contact-us/

Qt für VxWorks-Lizenzierung

Qt für VxWorks ist unter der Qt for Device Creation Professional (DCP) Lizenz erhältlich. Weitere Informationen finden Sie unter Qt-Preise.

Unterstützte Architekturen und VxWorks-Versionen

Qt 6.9 ist auf VxWorks 24.03 verifiziert.

Unterstützte Architekturen:

• ARM-v7-getestet auf BD-SL-i.MX6. Verwendetes BSP: fsl_imx6
• x86_64-getestet auf Intel NUC6i3SYH. Verwendetes BSP: itl_generic

Wenn Sie an späteren Qt-Versionen interessiert sind, wenden Sie sich bitte an Qt Professional Services.

Anforderungen für VxWorks

Qt Widgets Anwendungen

• POSIX-Unterstützung
• C++17-Unterstützung

Qt Quick 2 Anwendungen

Alle Funktionen, die für Qt Widgets Anwendungen erforderlich sind, und zusätzlich die folgenden:

• GPU-Gerät (GPUDEV) für OpenGL ES 2.0

Unterstützte Module

Die meisten wesentlichen Qt-Module und einige Zusatzmodule werden unterstützt.

Unterstützte wesentliche Module

Unterstützte Add-Ons

Plattform-Hinweise

Qt ist für die Verwendung durch RTP-Anwendungen vorbereitet, es gibt keine Unterstützung für DKM.

Mit der Veröffentlichung von Qt 5.0 enthält Qt keine eigene Implementierung des Fenstersystems mehr: QWS ist keine unterstützte Plattform mehr. Für Single-Process-Anwendungen ist die Qt Platform Abstraction eine bessere Lösung.

Es gibt ein Plugin, das auf VxWorks verwendbar ist: EGLFS. Die Verfügbarkeit dieses Plugins hängt von der Konfiguration von Qt ab.

Konfigurieren für ein bestimmtes Gerät

Bereiten Sie Ihre Umgebung vor, indem Sie das VxWorks SDK installieren und eine WindRiver-Lizenz erwerben, die vom Installationsprogramm und für die Erstellung von VxWorks-Images benötigt wird. Suchen Sie nach dem entsprechenden Installationsprogramm unter {https://gallery.windriver.com/portal/products}.

Die Erstellung von Qt für ein bestimmtes Gerät erfordert eine Qt 6-Installation für den Kompilierungshost, eine Toolchain und eine Sysroot. Zusätzlich benötigen einige Geräte herstellerspezifischen Anpassungscode für EGL und OpenGL 2.0 Unterstützung.

VxWorks Image Anforderungen

Qt für VxWorks erfordert bestimmte VxWorks-Image-Bundles und -Komponenten, die in die Basissoftware eingebettet werden müssen, damit Qt kompiliert und ordnungsgemäß funktioniert. Die Liste ist keineswegs vollständig, da sie von den Hardware-, Software- und Systemanforderungen Ihres Projekts abhängt. Die folgende Tabelle enthält jedoch diejenigen, die für das Funktionieren bestimmter Funktionen (einschließlich Touchscreen-Unterstützung) zwingend erforderlich sind. Beachten Sie auch, dass sich diese mit den verschiedenen VxWorks-Versionen ändern können.

Beispiel einer VSB-Konfiguration für die BSPs fsl_imx6 und itl_generic

Sie müssen die folgenden Features zu VSB hinzufügen, damit Qt richtig funktioniert. Für weitere Details lesen Sie bitte die WindRiver VxWorks Dokumentation.

Die folgenden Konfigurationsvariablen werden implizit hinzugefügt und Sie müssen sie entfernen:

Sie müssen die folgenden Variablen in der Konfiguration hinzufügen:

Beispiel VIP Konfiguration für fsl_imx6 und itl_generic BSPs

Für weitere Details lesen Sie bitte die WindRiver VxWorks Dokumentation.

Die folgenden Komponenten werden implizit hinzugefügt und Sie müssen sie entfernen:

VIP-Parameter

Sie müssen die folgenden Parameter hinzufügen, damit Qt unter VxWorks ordnungsgemäß läuft:

Erstellen von Qt 6 für VxWorks

Host-Build

Ein Host-Build von Qt muss verfügbar sein, um Qt crosskompilieren zu können. Das liegt daran, dass während des Builds bestimmte Werkzeuge (wie moc, rcc, qmlcachegen und qsb) vom Host-Build aufgerufen werden. Sie haben die folgenden Optionen:

• Erstellen von Qt-Quellen für den Host,
• Installieren des Host-Builds mit Qt Online Installer.

Es ist jedoch ratsam, sicherzustellen, dass Sie Qt auch für das Desktop-Target auf dem Host kompilieren können, da die gleichen Werkzeuge auch für die Kompilierung für VxWorks benötigt werden.

Ausführen des Configure-Skripts

Die Befehle zum Konfigurieren, Erstellen und Installieren von Qt 6 für den Host sind die folgenden:

./configure \
    -cmake-generator "Ninja" \
    -extprefix <path/to/Qt6/host/installation/dir> \
    -submodules qtbase,qtdeclarative,qtquick3d,qtshadertools \
    -nomake tests \
    -nomake examples \
    -- \
    -B <host/build/directory>
cd <host/build/directory>
cmake --build . --parallel
cmake --install .

Diese Befehle installieren Qt 6 für den Host unter <path_to_Qt 6_host_installation_dir>.

Erstellen von Qt 6 für das Zielsystem

Einrichten der Build-Umgebung

Bevor Sie configure ausführen und Qt 6 bauen, müssen Sie die VxWorks Development Shell in der Eingabeaufforderung öffnen.

• Linux:

  cd <VxWorks installation directory>
  ./wrenv.sh -p vxworks
  export WIND_CC_SYSROOT=<path to VxWorks VSB directory>

• Windows:

  cd <VxWorks installation directory>
  wrenv -p vxworks
  export WIND_CC_SYSROOT=<path to VxWorks VSB directory>

Vorbereiten der benutzerdefinierten CMake-Toolchain-Datei

Um Grafikbibliotheken aus dem BSP einzubinden, müssen Sie zunächst eine CMake-Toolchain-Datei erstellen. Ein Beispiel für eine CMake-Toolchain-Datei für ein BD-SL-i.MX6-Gerät:

# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

if(QT_VXWORKS_TOOLCHAIN_FILE)
    set(_original_toolchain_file "${QT_VXWORKS_TOOLCHAIN_FILE}")
elseif(DEFINED ENV{QT_VXWORKS_TOOLCHAIN_FILE})
    set(_original_toolchain_file "$ENV{QT_VXWORKS_TOOLCHAIN_FILE}")
else()
    message(FATAL_ERROR "QT_VXWORKS_TOOLCHAIN_FILE is not set.")
endif()

if(NOT EXISTS "${_original_toolchain_file}")
    message(FATAL_ERORR "${_original_toolchain_file} doesn't exists.")
endif()

include("${_original_toolchain_file}")
unset(_original_toolchain_file)

list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES QT_VXWORKS_TOOLCHAIN_FILE)

set(_common_lib_path "${CMAKE_SYSROOT}/usr/lib/common")
set(EGL_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to EGL include directory" FORCE)
set(EGL_LIBRARY ${_common_lib_path}/libgfxFslVivEGL.so CACHE PATH "Path to EGL lib" FORCE)
set(GLESv2_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to GLES include directory" FORCE)
set(GLESv2_LIBRARY ${_common_lib_path}/libgfxFslVivGLESv2.so CACHE PATH "Path to GLES lib" FORCE)

set(VxWorksPlatformGraphics_DEFINES "-D_FSLVIV")
set(VxWorksPlatformGraphics_LIBRARIES_PACK
    "${_common_lib_path}/libgfxFslVivEGL.so"
    "${_common_lib_path}/libgfxFslVivGLESv2.so"
    "${_common_lib_path}/libgfxFslVivGAL.so"
    "${_common_lib_path}/libgfxFslVivGLSLC.so"
    "${_common_lib_path}/libgfxFslVivVDK.so"
    "${_common_lib_path}/libxml.so"
)

set(VxWorksPlatformGraphics_REQUIRED_LIBRARIES
    ${VxWorksPlatformGraphics_LIBRARIES_PACK}
    ${EGL_LIBRARY}
    ${GLESv2_LIBRARY}
)
unset(_common_lib_path)

Ein Beispiel für Intel NUC6i3SYH:

# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

if(QT_VXWORKS_TOOLCHAIN_FILE)
    set(_original_toolchain_file "${QT_VXWORKS_TOOLCHAIN_FILE}")
elseif(DEFINED ENV{QT_VXWORKS_TOOLCHAIN_FILE})
    set(_original_toolchain_file "$ENV{QT_VXWORKS_TOOLCHAIN_FILE}")
else()
    message(FATAL_ERROR "QT_VXWORKS_TOOLCHAIN_FILE is not set.")
endif()

if(NOT EXISTS "${_original_toolchain_file}")
    message(FATAL_ERORR "${_original_toolchain_file} doesn't exists.")
endif()

include("${_original_toolchain_file}")
unset(_original_toolchain_file)

list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES QT_VXWORKS_TOOLCHAIN_FILE)

set(_common_lib_path "${CMAKE_SYSROOT}/usr/lib/common")
set(EGL_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to EGL include directory" FORCE)
set(EGL_LIBRARY ${_common_lib_path}/libgfxMesaEGL.so CACHE PATH "Path to EGL lib" FORCE)
set(GLESv2_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to GLES include directory" FORCE)
set(GLESv2_LIBRARY ${_common_lib_path}/libgfxMesaGL.so CACHE PATH "Path to GLES lib" FORCE)

set(VxWorksPlatformGraphics_DEFINES "-D__vxworks -D__VXWORKS")
set(VxWorksPlatformGraphics_LIBRARIES_PACK
    "${_common_lib_path}/libgfxMesaEGL.so"
    "${_common_lib_path}/libgfxMesaGL.so"
    "${_common_lib_path}/libgfxMesaSw.so"
    "${_common_lib_path}/libgfxMesa.so"
    "${_common_lib_path}/libgfxMesaDriI965.so"
    "${_common_lib_path}/libgfxLibDRM.so"
    "${_common_lib_path}/libxml.so"
)

set(VxWorksPlatformGraphics_REQUIRED_LIBRARIES
    ${VxWorksPlatformGraphics_LIBRARIES_PACK}
    ${EGL_LIBRARY}
    ${GLESv2_LIBRARY}
)
unset(_common_lib_path)

Ein Beispiel für I.MX8:

# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

if(QT_VXWORKS_TOOLCHAIN_FILE)
    set(_original_toolchain_file "${QT_VXWORKS_TOOLCHAIN_FILE}")
elseif(DEFINED ENV{QT_VXWORKS_TOOLCHAIN_FILE})
    set(_original_toolchain_file "$ENV{QT_VXWORKS_TOOLCHAIN_FILE}")
else()
    message(FATAL_ERROR "QT_VXWORKS_TOOLCHAIN_FILE is not set.")
endif()

if(NOT EXISTS "${_original_toolchain_file}")
    message(FATAL_ERORR "${_original_toolchain_file} doesn't exists.")
endif()

include("${_original_toolchain_file}")
unset(_original_toolchain_file)

list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES QT_VXWORKS_TOOLCHAIN_FILE)

set(_common_lib_path "${CMAKE_SYSROOT}/usr/lib/common")
set(EGL_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to EGL include directory" FORCE)
set(EGL_LIBRARY ${_common_lib_path}/libgfxNxpVivEGL.so CACHE PATH "Path to EGL lib" FORCE)
set(GLESv2_INCLUDE_DIR ${CMAKE_SYSROOT}/usr/h/public CACHE PATH "Path to GLES include directory" FORCE)
set(GLESv2_LIBRARY ${_common_lib_path}/libgfxNxpVivGLESv2.so CACHE PATH "Path to GLES lib" FORCE)

set(VxWorksPlatformGraphics_DEFINES "-D_NXPVIV -D__vxworks -D__VXWORKS__")
set(VxWorksPlatformGraphics_LIBRARIES_PACK
    "${_common_lib_path}/libgfxNxpVivGAL.so"
    "${_common_lib_path}/libgfxNxpVivEGL.so"
    "${_common_lib_path}/libgfxNxpVivGLSLC.so"
    "${_common_lib_path}/libgfxNxpVivGLESv2.so"
    "${_common_lib_path}/libgfxNxpVivGLESv1_CM.so"
    "${_common_lib_path}/libgfxNxpVivVSC.so"
    "${_common_lib_path}/libxml.so"
)

set(VxWorksPlatformGraphics_REQUIRED_LIBRARIES
    ${VxWorksPlatformGraphics_LIBRARIES_PACK}
    ${EGL_LIBRARY}
    ${GLESv2_LIBRARY}
)
unset(_common_lib_path)

Ausführen von Qt 6 Configure für das Target

Nachfolgend finden Sie ein Beispiel für eine Build-Konfiguration für das BD-SL-i.MX6. Für die meisten VxWorks-Boards sieht der configure-Befehl sehr ähnlich aus. Standardmäßig ist Qt 6 für die Verwendung von Shared Libraries konfiguriert. Um Qt 6 statisch zu bauen, fügen Sie die Option -static zu configure hinzu.

Stellen Sie sicher, dass die Umgebungsvariable {WIND_CC_SYSROOT} auf das VxWorks VSB-Root-Verzeichnis gesetzt ist.

./configure \
    -cmake-generator "Ninja" \
    -icu \
    -eglfs \
    -qpa eglfs \
    -submodules "qtbase,qtdeclarative,qtmultimedia,qtquick3d,qtgraphs,qtimageformats,qtsvg,qtshadertools,qtvirtualkeyboard" \
    -- \
    -B <target/build/directory> \
    -DQT_VXWORKS_TOOLCHAIN_FILE=<path/to/VSB/mk/toolchain.cmake> \
    -DFEATURE_vulkan=OFF \
    -DQT_QMAKE_TARGET_MKSPEC=vxworks-clang \
    -DQT_HOST_PATH=<path/to/Qt6/host/installation/dir> \
    -DCMAKE_STAGING_PREFIX:PATH=<path/to/Qt6/target/installation/dir> \
    -DCMAKE_TOOLCHAIN_FILE=<path/to/cmake/for/graphics/file/created/above> \

Es wird empfohlen, Qt 6 mit einem Shadow-Build zu erstellen. Siehe Qt-Konfigurationsoptionen für weitere Informationen.

Nach der Konfiguration bauen und installieren Sie Qt 6 für VxWorks mit diesen Befehlen:

cd <host build directory>
cmake --build . --parallel
cmake --install .

Plattform-Plugins für VxWorks-Geräte

Qt für VxWorks unterstützt das EGLFS-Plattform-Plugin für eine native Fenstersubstitution. Lesen Sie mehr über seine Konfiguration in EGLFS.

Erstellen von Qt-Anwendungen

Um eine Qt-Anwendung zu erstellen, müssen Sie das QT_VXWORKS_TOOLCHAIN_FILE als Umgebungsvariable oder als Define setzen.

Ein Beispiel für die Erstellung der Qt-Demo clocks:

export WIND_CC_SYSROOT=<path/to/VxWorks/VSB/directory>
export QT_VXWORKS_TOOLCHAIN_FILE=<path/to/the/BSP/toolchain.cmake>
<path/to/Qt6/target/installation/dir>/bin/qt-cmake -G Ninja -S ~/Qt/Examples/Qt-6.9.0/demos/clocks -B <path/to/build/directory>
cd <path/to/build/directory>
cmake --build . --parallel

Qt-Anwendungen starten

Das folgende Beispiel zeigt, wie man eine Anwendung startet, wenn Qt 6 mit Shared Libraries gebaut wurde. Bei einem statisch erstellten Qt 6 brauchen Sie die Umgebungsvariable LD_LIBRARY_PATH nicht für die Qt-Bibliotheken zu verwenden, aber sie muss auf den Ort der gemeinsam genutzten VxWorks-Bibliotheken zeigen (zum Beispiel libc und OpenGL ES 2.0). Für die statischen Qt 6-Bibliotheken wird sie nicht benötigt.

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

Debuggen von Qt-Anwendungen

Um Qt-Anwendungen zu debuggen, müssen Sie Ihrer VxWorks VSB Folgendes hinzufügen:

vxprj vsb config -s -add "_WRS_CONFIG_TCF_GDB_RSP=y"

Zu Ihrer VxWorks VIP-Konfiguration hinzufügen:

"INCLUDE_DEBUG_AGENT"
"INCLUDE_DEBUG_AGENT_START"
"INCLUDE_STANDALONE_SYM_TBL"

Von der Kommandozeile aus

1. Starten Sie die zu debuggende Anwendung auf dem Gerät über SSH oder die serielle USB-Verbindung:

   rtpSp("<Qt 6 VxWorks application>", 200, 0x100000, 0, 0x01000000)

2. Starten Sie den VxWorks-Debugger auf dem PC:

   vxgdb <binary to debug>

3. Listen Sie die laufenden Prozesse im Debugger auf:

   monitor ps

4. Hängen Sie den Debugger an die bereits laufende Anwendung an:

   "attach <id from monitor>"

5. Verwenden Sie GDB-Befehle zum Debuggen.

Von der Workbench aus

1. Erstellen Sie ein CMake-Echtzeitprozess-Projekt.

   

2. Setzen Sie die VSB, die Debugging konfiguriert hat.
3. Entfernen Sie set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") aus CMakeLists.txt.
4. Fügen Sie Qt CMake-bezogenen Code zur CMakeLists.txt hinzu, wie in Getting started with CMake beschrieben.
5. Vor project() fügen Sie unset(CMAKE_TOOLCHAIN_FILE CACHE) und CMAKE_TOOLCHAIN_FILE hinzu, die auf die Qt6-Toolchain-Datei und QT_CHAINLOAD_TOOLCHAIN_FILE auf die VSB-Toolchain-Datei verweisen. Zum Beispiel:

   unset(CMAKE_TOOLCHAIN_FILE CACHE)
   set(CMAKE_TOOLCHAIN_FILE "/home/qtuser/VxWorks/qt/target_gdb/lib/cmake/Qt6/qt.toolchain.cmake")
   set(QT_CHAINLOAD_TOOLCHAIN_FILE "/home/qtuser/VxWorks/fsl_imx6_2_0_6_2_VSB_gdb/mk/toolchain.cmake")

6. Erstellen Sie die Anwendung Project.
7. Erstellen Sie eine neue Verbindung.

   

8. Starten Sie den RTP-Prozess zum Debuggen.

   

9. Klicken Sie auf Erweiterte Optionen.

   

10. Setzen Sie die Stackgröße auf 0x100000.

    

Qt für VxWorks Eingabe-Plugins

VxWorks verwendet seine eigene Implementierung von libevdev, die eine API hat, die der von Linux sehr ähnlich ist, sich aber in den Fähigkeiten unterscheidet. Aus diesem Grund implementiert Qt für VxWorks separate Eingabe-Plugins für Maus, Tastatur und Touchscreen, die auf {inputs-linux-device.html}{Linux evdev} basieren, mit Unterschieden, die im Folgenden erläutert werden.

VxMouse

VxMouse verwendet das gleiche Konfigurationsschema wie EvdevMouse, mit Ausnahme einer anderen Umgebungsvariablen: QT_QPA_VXEVDEV_MOUSE_PARAMETERS. Außerdem ignoriert VxMouse die Parameter nocompress, dejitter und grab.

VxTastatur

VxKeyboard verwendet dasselbe Konfigurationsschema wie EvdevKeyboard, mit Ausnahme einer anderen Umgebungsvariablen: QT_QPA_VXEVDEV_KEYBOARD_PARAMETERS.

VxTouch

VxTouch verwendet das gleiche Konfigurationsschema wie EvdevTouch, mit Ausnahme der unterschiedlichen Umgebungsvariablen:

• QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS
• QT_QPA_VXEVDEV_DEBUG

Zusätzlich fügt VxTouch zwei neue Parameter hinzu:

Beschränkungen

Video-Speicher

Auf Systemen mit einer bestimmten Menge an dediziertem Videospeicher ist möglicherweise besondere Vorsicht geboten, bevor Qt-Anwendungen ausgeführt werden, die auf Qt Quick oder Klassen wie QOpenGLWidget basieren. Die Standardeinstellung kann für solche Anwendungen unzureichend sein, insbesondere wenn sie auf einem Bildschirm mit hoher Auflösung (z. B. Full HD) angezeigt werden. In diesem Fall kann es zu unerwarteten Fehlern kommen. Es wird daher empfohlen, dafür zu sorgen, dass mindestens 128 MB GPU-Speicher zur Verfügung stehen. Bei Systemen, die keinen festen Speicherplatz für die GPU reserviert haben, stellt dies kein Problem dar.