Qt für VxWorks

Weitere Informationen erhalten Sie bei The Qt Company: https://www.qt.io/contact-us/

Lizenzierung von Qt für VxWorks

„Qt for 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.10 wurde unter VxWorks 25.03 getestet.

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 neueren 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, sowie zusätzlich Folgendes:

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

Unterstützte Module

Die wichtigsten Qt-Module sowie einige Zusatzmodule werden unterstützt.

Unterstützte Kernmodule

Unterstützte Add-ons

Hinweise zur Plattform

Qt ist für die Verwendung in RTP-Anwendungen vorbereitet; DKM wird nicht unterstützt.

Mit der Veröffentlichung von Qt 5.0 enthält Qt keine eigene Implementierung eines Fenstersystems mehr: QWS wird nicht mehr als Plattform unterstützt. Für Anwendungsfälle mit einem einzigen Prozess ist die Qt Platform Abstraction die bessere Lösung.

Es gibt ein Plugin, das unter VxWorks verwendet werden kann: EGLFS. Die Verfügbarkeit dieses Plugins hängt von der Konfiguration von Qt ab.

Konfiguration für ein bestimmtes Gerät

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

Das Erstellen von Qt für ein bestimmtes Gerät erfordert eine Qt-6-Installation auf dem Kompilierungshost, eine Toolchain und ein Sysroot. Weitere Informationen finden Sie unter „Cross-Kompilierung von Qt “. Darüber hinaus erfordern einige Geräte herstellerspezifischen Anpassungscode für die Unterstützung von EGL und OpenGL 2.0.

Anforderungen an VxWorks-Images

Qt für VxWorks erfordert, dass bestimmte VxWorks-Image-Bundles und -Komponenten in die Basissoftware eingebettet werden, damit Qt kompiliert werden kann 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 Komponenten, die für die Funktion bestimmter Funktionen (einschließlich Touchscreen-Unterstützung) zwingend erforderlich sind. Beachten Sie außerdem, dass sich diese je nach VxWorks-Version ändern können.

Beispiel für eine VSB-Konfiguration für die BSPs „fsl_imx6“ und „itl_generic“

Sie müssen die folgenden Funktionen zum VSB hinzufügen, damit Qt ordnungsgemäß funktioniert. Weitere Details finden Sie in der Wind River VxWorks-Dokumentation.

Die folgenden Konfigurationsvariablen werden implizit hinzugefügt und müssen von Ihnen entfernt werden:

Sie müssen die folgenden Variablen zur Konfiguration hinzufügen:

Beispiel für eine VIP-Konfiguration für die BSPs „fsl_imx6“ und „itl_generic“

Weitere Informationen finden Sie in der WindRiver VxWorks-Dokumentation.

Die folgenden Komponenten werden implizit hinzugefügt und müssen von Ihnen entfernt werden:

VIP-Parameter

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

Qt 6 für VxWorks kompilieren

Host-Build

Für die Cross-Kompilierung von Qt muss eine Host-Version von Qt verfügbar sein. Der Grund dafür ist, dass während des Kompiliervorgangs bestimmte Tools (wie z. B. moc, rcc, qmlcachegen und qsb) aus der Host-Version aufgerufen werden. Sie haben folgende Möglichkeiten:

• Qt-Quellcode für den Hostkompilieren,
• Installieren des Host-Builds mit Qt Online Installer.

Es ist jedoch ratsam, sicherzustellen, dass Sie Qt auch auf dem Host für das Desktop-Ziel kompilieren können, da dieselben Werkzeuge auch beim Kompilieren für VxWorks benötigt werden.

Ausführen des Configure-Skripts

Die Befehle zum Konfigurieren, Kompilieren und Installieren von Qt 6 für den Host lauten wie folgt:

./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> “.

Kompilieren von Qt 6 für das Zielsystem

Einrichten der Build-Umgebung

Bevor Sie „configure“ ausführen und Qt 6 kompilieren, 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>

Vorbereitung 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 das Gerät BD-SL-i.MX6:

# Copyright (C) 2024 The Qt Company Ltd.

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 den Intel NUC6i3SYH:

# Copyright (C) 2024 The Qt Company Ltd.

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)

Ausführen von „qt 6 configure“ für das Ziel

Nachfolgend finden Sie ein Beispiel für eine Build-Konfiguration für das BD-SL-i.MX6. Bei den meisten VxWorks-Boards sieht der „configure“-Befehl sehr ähnlich aus. Standardmäßig ist Qt 6 für die Verwendung von gemeinsam genutzten Bibliotheken konfiguriert. Um Qt 6 statisch zu kompilieren, fügen Sie die Option „ -static “ zu „configure“ hinzu.

Stellen Sie sicher, dass die Umgebungsvariable {WIND_CC_SYSROOT} auf das VxWorks-VSB-Stammverzeichnis 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 mithilfe eines Shadow-Builds zu erstellen. Weitere Informationen finden Sie unter „Qt-Konfigurationsoptionen “.

Nach der Konfiguration erstellen und installieren Sie Qt 6 für VxWorks mit folgenden 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 Fensterersetzung. Weitere Informationen zur Konfiguration finden Sie unter „EGLFS“.

Erstellen von Qt-Anwendungen

Um eine Qt-Anwendung zu erstellen, müssen Sie die Umgebungsvariable `QT_VXWORKS_TOOLCHAIN_FILE` setzen oder als Makro definieren.

Ein Beispiel zum Erstellen 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.10.0/demos/clocks -B <path/to/build/directory>
cd <path/to/build/directory>
cmake --build . --parallel

Umgebungsvariablen setzen

Legen Sie die Umgebungsvariablen beispielsweise wie folgt in einem Startskript fest:

putgenv("QT_QPA_FONTDIR=/bd0a/fonts")
putgenv("QT_QPA_EGLFS_FB=/dev/fb0")
putgenv("LD_LIBRARY_PATH=/bd0a/lib/gfx;/bd0a/lib/llvm;/bd0a/lib/icu")
putgenv("ICU_DATA=/bd0a/icu/icudt73l.dat")
putgenv("QT_QPA_EGLFS_INTEGRATION=eglfs_kms")
putgenv("QT_QPA_EGLFS_FB=/dev/fb0")
putgenv("QT_QPA_EGLFS_KMS_CONFIG=/bd0a/kms.conf")
putgenv("QML_DISABLE_DISK_CACHE=1")

Die Datei „ kms.conf “ für das Intel KabyLake-Gerät könnte beispielsweise wie folgt aussehen:

{
  "device": "/dev/dri/card0",
  "hwcursor": false,
  "pbuffers": true,
  "outputs": [
    {
      "name": "DP",
      "mode": "1920x1080"
    }
  ]
}

Ausführen von Qt-Anwendungen

Das folgende Beispiel zeigt, wie eine Anwendung mit dem VxWorks-Befehl „ rtpSp “ gestartet wird:

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

Debuggen von Qt-Anwendungen

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

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

Fügen Sie Ihrer VxWorks-VIP-Konfiguration Folgendes hinzu:

"INCLUDE_DEBUG_AGENT"
"INCLUDE_DEBUG_AGENT_START"
"INCLUDE_STANDALONE_SYM_TBL"

Über die Befehlszeile

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. Verbinden Sie den Debugger mit der bereits laufenden Anwendung:

   "attach <id from monitor>"

5. Verwenden Sie GDB-Befehle zum Debuggen.

Aus Qt Creator

Informationen zum Debuggen mit „ Qt Creator “ finden Sie unter Qt Creator: Debuggen von C++-Anwendungen auf VxWorks-Geräten.

Aus der Workbench

1. Erstellen Sie ein CMake-Real-Time-Process-Projekt.

   

2. Legen Sie das VSB fest, für das die Debugging-Konfiguration vorgenommen wurde.
3. Entfernen Sie „set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")“ aus der Datei „CMakeLists.txt“.
4. Fügen Sie Qt-CMake-bezogenen Code gemäß „Erste Schritte mit CMake“ zur „CMakeLists.txt“ hinzu.
5. Fügen Sie vor „ project() “ die Zeile „ unset(CMAKE_TOOLCHAIN_FILE CACHE) “ ein und fügen Sie „ CMAKE_TOOLCHAIN_FILE “ hinzu, wobei Sie auf die Qt6-Toolchain-Datei verweisen, sowie „ QT_CHAINLOAD_TOOLCHAIN_FILE “ auf die VSB-Toolchain-Datei. 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 das Anwendungsprojekt.
7. Erstellen Sie eine neue Verbindung.

   

8. Starten Sie den RTP-Prozess zum Debuggen.

   

9. Klicken Sie auf „Erweiterte Optionen“.

   

10. Stellen Sie die Stackgröße auf 0x100000 ein.

    

Qt-Eingabe-Plugins für VxWorks

VxWorks verwendet eine eigene Implementierung von „ libevdev “, deren API der von Linux sehr ähnlich ist, sich jedoch in den Funktionen unterscheidet. Aus diesem Grund implementiert Qt für VxWorks separate Eingabe-Plugins zur Steuerung von Maus, Tastatur und Touchscreen, die auf {inputs-linux-device.html}{Linux evdev} basieren, wobei die Unterschiede im Folgenden erläutert werden.

VxMouse

VxMouse verwendet dasselbe Konfigurationsschema wie EvdevMouse, mit Ausnahme einer anderen Umgebungsvariablen: „ QT_QPA_VXEVDEV_MOUSE_PARAMETERS “. Zudem ignoriert „ VxMouse “ die Parameter „ nocompress “, „ dejitter “ und „ grab “.

VxKeyboard

VxKeyboard verwendet dasselbe Konfigurationsschema wie EvdevKeyboard, mit Ausnahme der Umgebungsvariable: QT_QPA_VXEVDEV_KEYBOARD_PARAMETERS.

VxTouch

VxTouch verwendet dasselbe Konfigurationsschema wie EvdevTouch, mit Ausnahme folgender Umgebungsvariablen:

• QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS
• QT_QPA_VXEVDEV_DEBUG

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

Einschränkungen

Grafikspeicher

Bei Systemen mit einer festen Menge an dediziertem Grafikspeicher ist möglicherweise besondere Vorsicht geboten, bevor Qt-Anwendungen ausgeführt werden, die auf Qt Quick oder Klassen wie QOpenGLWidget basieren. Die Standardeinstellung könnte 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 können unerwartete Fehlfunktionen auftreten. Es wird daher empfohlen, sicherzustellen, dass mindestens 128 MB GPU-Speicher verfügbar sind. Bei Systemen, bei denen keine feste Speichermenge für die GPU reserviert ist, stellt dies kein Problem dar.