Qt pour VxWorks

Contactez The Qt Company pour plus d'informations : https://www.qt.io/contact-us/

Licence de Qt pour VxWorks

Qt pour VxWorks est disponible sous la licence Qt for Device Creation Professional (DCP). Pour plus d'informations, voir Qt Pricing.

Architectures et versions de VxWorks prises en charge

Qt 6.10 est vérifié sur VxWorks 25.03.

Architectures prises en charge :

• ARM-v7-Testé sur BD-SL-i.MX6. BSP utilisé : fsl_imx6
• x86_64-Testé sur Intel NUC6i3SYH. BSP utilisé : itl_generic

Si vous êtes intéressé par les versions ultérieures de Qt, veuillez contacter les services professionnels de Qt.

Configuration requise pour VxWorks

Qt Widgets Applications

• Prise en charge de POSIX
• Prise en charge de C++17

Qt Quick 2 applications

Toutes les fonctionnalités requises pour les applications Qt Widgets, ainsi que les éléments suivants :

• Dispositif GPU (GPUDEV) pour OpenGL ES 2.0

Modules pris en charge

La plupart des modules Qt essentiels et certains modules complémentaires sont pris en charge.

Modules essentiels pris en charge

Compléments pris en charge

Notes sur la plate-forme

Qt est préparé pour être utilisé par des applications RTP, il n'y a pas de support pour DKM.

Avec la sortie de Qt 5.0, Qt ne contient plus sa propre implémentation du système de fenêtres : QWS n'est plus une plate-forme prise en charge. Pour les cas d'utilisation d'un seul processus, l'abstraction de plate-forme Qt est une solution supérieure.

Il existe un plugin utilisable sur VxWorks : EGLFS. La disponibilité de ce plugin dépend de la configuration de Qt.

Configuration pour un appareil spécifique

Préparez votre environnement en installant le SDK VxWorks et en obtenant la licence WindRiver qui est nécessaire à l'installateur et à la construction des images VxWorks. Recherchez le programme d'installation approprié sur {https://gallery.windriver.com/portal/products}.

La construction de Qt pour un dispositif donné nécessite une installation de Qt 6 pour l'hôte de compilation, une chaîne d'outils et un sysroot. Voir la section Compilation croisée de Qt pour plus de détails. En outre, certains appareils nécessitent un code d'adaptation spécifique au fournisseur pour le support EGL et OpenGL 2.0.

Exigences de l'image VxWorks

Qt pour VxWorks nécessite que certains bundles et composants d'images VxWorks soient intégrés dans le logiciel de base pour que Qt se compile et fonctionne correctement. La liste n'est en aucun cas exhaustive car elle dépend du matériel, du logiciel et des exigences du système de votre projet. Cependant, le tableau suivant contient ceux qui sont obligatoires pour que certaines fonctionnalités fonctionnent (y compris la prise en charge des écrans tactiles). Notez également que ces exigences peuvent changer en fonction des versions de VxWorks.

Exemple de configuration VSB pour les BSP fsl_imx6 et itl_generic

Vous devez ajouter les fonctionnalités suivantes au VSB pour que Qt fonctionne correctement. Pour plus de détails, veuillez consulter la documentation WindRiver VxWorks.

Les variables de configuration suivantes sont ajoutées implicitement et vous devez les supprimer :

Vous devez ajouter les variables suivantes à la configuration :

Exemple de configuration VIP pour les BSP fsl_imx6 et itl_generic

Pour plus de détails, veuillez consulter la documentation WindRiver VxWorks.

Les composants suivants sont ajoutés implicitement et vous devez les supprimer :

Paramètres VIP

Vous devez ajouter les paramètres suivants pour que Qt fonctionne correctement sur VxWorks :

Construction de Qt 6 pour VxWorks

Construction de l'hôte

Une version hôte de Qt doit être disponible pour la compilation croisée de Qt. En effet, lors de la compilation, certains outils (tels que moc, rcc, qmlcachegen, et qsb) sont invoqués à partir de la compilation hôte. Vous disposez des options suivantes :

• Construire les sources Qt pour l'hôte,
• Installer la compilation de l'hôte à l'aide de Qt Online Installer.

Cependant, il est conseillé de s'assurer que vous pouvez également construire Qt pour la cible desktop sur l'hôte car les mêmes outils sont également nécessaires lors de la compilation pour VxWorks.

Exécution du script de configuration

Les commandes pour configurer, construire et installer Qt 6 pour l'hôte sont les suivantes :

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

Ces commandes installent Qt 6 pour l'hôte dans <path_to_Qt 6_host_installation_dir>.

Construction de Qt 6 pour la cible

Configuration de l'environnement de construction

Avant d'exécuter la configuration et la construction de Qt 6, vous devez ouvrir le VxWorks Development Shell dans l'invite de commande.

• 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>

Préparation du fichier CMake Toolchain personnalisé

Pour inclure des bibliothèques graphiques à partir du BSP, vous devez d'abord créer un fichier CMake toolchain. Exemple de fichier CMake toolchain pour le périphérique BD-SL-i.MX6 :

# 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)

Un exemple pour 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)

Configuration de Qt 6 pour la cible

Vous trouverez ci-dessous un exemple de configuration pour la BD-SL-i.MX6. Pour la plupart des cartes VxWorks, la commande configure est très similaire. Par défaut, Qt 6 est configuré pour utiliser des bibliothèques partagées. Pour construire Qt 6 statiquement, ajoutez l'option -static à la commande configure.

Assurez-vous que la variable d'environnement {WIND_CC_SYSROOT} est définie sur le répertoire racine de la carte VxWorks VSB.

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

Il est recommandé de construire Qt 6 à l'aide d'une compilation fantôme. Voir les options de configuration de Qt pour plus d'informations.

Après la configuration, construisez et installez Qt 6 pour VxWorks avec ces commandes :

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

Plugins de plate-forme pour les périphériques VxWorks

Qt pour VxWorks supporte le plugin de plateforme EGLFS pour une substitution de fenêtre native. Pour en savoir plus sur sa configuration, voir EGLFS.

Construire des applications Qt

Pour construire une application Qt, vous devez définir le fichier QT_VXWORKS_TOOLCHAIN_FILE comme variable d'environnement ou comme définition.

Un exemple pour construire la démo Qt des horloges :

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

Définition des variables d'environnement

Définissez les variables d'environnement dans un script de démarrage comme suit, par exemple :

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")

Le fichier kms.conf pour le périphérique Intel KabyLake peut ressembler à ceci, par exemple :

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

Exécution d'applications Qt

L'exemple suivant montre comment démarrer une application à l'aide de la commande VxWorks rtpSp:

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

Débogage des applications Qt

Pour déboguer les applications Qt, vous devez ajouter les éléments suivants à votre VSB VxWorks :

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

Dans votre configuration VIP VxWorks, ajoutez :

"INCLUDE_DEBUG_AGENT"
"INCLUDE_DEBUG_AGENT_START"
"INCLUDE_STANDALONE_SYM_TBL"

À partir de la ligne de commande

1. Lancez l'application à déboguer sur l'appareil via SSH ou la connexion série USB :

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

2. Démarrer le débogueur VxWorks sur le PC :

   vxgdb <binary to debug>

3. Lister les processus en cours dans le débogueur :

   monitor ps

4. Attacher le débogueur à l'application déjà en cours d'exécution :

   "attach <id from monitor>"

5. Utiliser les commandes GDB pour le débogage.

A partir de Qt Creator

Pour déboguer à partir de Qt Creator, voir Qt Creator: Debug C++ applications on VxWorks devices.

À partir de Workbench

1. Créez un projet CMake Real Time Process.

   

2. Définissez le VSB pour lequel le débogage est configuré.
3. Supprimer set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") de CMakeLists.txt.
4. Ajoutez le code lié à Qt CMake au fichier CMakeLists.txt en suivant la rubrique "Getting started with CMake" (Démarrer avec CMake).
5. Avant project(), ajoutez unset(CMAKE_TOOLCHAIN_FILE CACHE) et CMAKE_TOOLCHAIN_FILE pointant vers le fichier de la chaîne d'outils Qt6 et QT_CHAINLOAD_TOOLCHAIN_FILE vers le fichier de la chaîne d'outils VSB. Par exemple :

   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. Créez le projet d'application.
7. Créez une nouvelle connexion.

   

8. Lancez le processus RTP pour le débogage.

   

9. Cliquez sur Options avancées.

   

10. Définir la taille de la pile à 0x100000.

    

Plugins d'entrée Qt pour VxWorks

VxWorks utilise sa propre implémentation de libevdev, dont l'API est très similaire à celle de Linux, mais dont les capacités diffèrent. Pour cette raison, Qt implémente des plugins d'entrée séparés pour VxWorks afin de gérer la souris, le clavier et l'écran tactile, qui sont basés sur {inputs-linux-device.html}{Linux evdev}, avec des différences qui sont expliquées ci-dessous.

VxMouse

VxMouse utilise le même schéma de configuration que EvdevMouse, à l'exception d'une variable d'environnement différente : QT_QPA_VXEVDEV_MOUSE_PARAMETERS. En outre, VxMouse ignore les paramètres nocompress, dejitter et grab.

VxKeyboard

VxKeyboard utilise le même schéma de configuration que EvdevKeyboard, à l'exception d'une variable d'environnement différente : QT_QPA_VXEVDEV_KEYBOARD_PARAMETERS.

VxTouch

VxTouch utilise le même schéma de configuration qu'EvdevTouch, à l'exception de variables d'environnement différentes :

• QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS
• QT_QPA_VXEVDEV_DEBUG

De plus, VxTouch ajoute deux nouveaux paramètres :

Limitations

Mémoire vidéo

Les systèmes disposant d'une quantité fixe de mémoire vidéo dédiée peuvent nécessiter une attention particulière avant d'exécuter des applications Qt XML basées sur Qt Quick ou des classes telles que QOpenGLWidget. Le paramètre par défaut peut être insuffisant pour de telles applications, en particulier lorsqu'elles sont affichées sur un écran à haute résolution (par exemple, full HD). Dans ce cas, elles peuvent commencer à échouer de manière inattendue. Il est donc recommandé de s'assurer qu'il y a au moins 128 Mo de mémoire GPU disponible. Pour les systèmes qui ne disposent pas d'une quantité fixe de mémoire réservée au GPU, ce problème ne se pose pas.