Qt pour VxWorks

Pour plus d'informations, contactez The Qt Company : https://www.qt.io/contact-us/

Licences Qt pour VxWorks

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

Architectures et versions de VxWorks prises en charge

Qt 6.10 a été testé 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 des versions plus récentes de Qt, veuillez contacter les services professionnels 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 suivantes :

• Périphérique GPU (GPUDEV) pour OpenGL ES 2.0

Modules pris en charge

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

Modules essentiels pris en charge

Modules complémentaires pris en charge

Remarques sur les plateformes

Qt est conçu pour être utilisé par les applications RTP ; il n'y a pas de prise en charge de DKM.

Avec la sortie de Qt 5.0, Qt ne contient plus sa propre implémentation de système de fenêtrage : QWS n'est plus une plateforme prise en charge. Pour les cas d'utilisation à processus unique, la Qt Platform Abstraction constitue une solution plus performante.

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

Configuration pour un périphérique spécifique

Préparez votre environnement en installant le SDK VxWorks et en vous procurant la licence WindRiver requise par le programme d'installation et pour la création d'images VxWorks. Recherchez le programme d'installation approprié sur {https://gallery.windriver.com/portal/products}.

La compilation de Qt pour un périphérique donné nécessite l'installation de Qt 6 sur l'hôte de compilation, une chaîne d'outils et un sysroot. Reportez-vous à la section « Compilation croisée de Qt » pour plus de détails. De plus, certains périphériques nécessitent un code d'adaptation spécifique au fabricant pour la prise en charge d'EGL et d'OpenGL 2.0.

Exigences relatives aux images VxWorks

Qt pour VxWorks nécessite l’intégration de certains ensembles d’images VxWorks et composants dans le logiciel de base afin que Qt puisse se compiler et fonctionner correctement. Cette liste n’est en aucun cas exhaustive, car elle dépend des exigences matérielles, logicielles et système de votre projet. Cependant, le tableau suivant répertorie les éléments indispensables au fonctionnement de certaines fonctionnalités (notamment la prise en charge des écrans tactiles). Notez également que ces éléments peuvent varier selon les 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 au fichier de 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 sous VxWorks :

Compilation de Qt 6 pour VxWorks

Compilation sur l'hôte

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

• Compilation des sources Qt pour l’hôte,
• Installer la compilation de l’hôte à l’aide de Qt Online Installer.

Il est toutefois conseillé de vous assurer que vous pouvez également compiler Qt pour la cible de bureau sur l’hôte, car les mêmes outils sont également nécessaires lors de la compilation pour VxWorks.

Exécution du script « Configure »

Les commandes permettant de configurer, de compiler et d'installer Qt 6 sur 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 sur l'hôte dans le répertoire <path_to_Qt 6_host_installation_dir>.

Compilation de Qt 6 pour la cible

Configuration de l’environnement de compilation

Avant d'exécuter la commande « configure » et de compiler 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 de chaîne d'outils CMake personnalisée

Pour inclure les bibliothèques graphiques du BSP, vous devez d'abord créer un fichier de chaîne d'outils CMake. Voici un exemple de fichier de chaîne d'outils CMake pour le périphérique 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)

Exemple pour l'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)

Exécution de la commande « configure » de Qt 6 pour la cible

Vous trouverez ci-dessous un exemple de configuration de compilation 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 compiler Qt 6 de manière statique, 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 du VSB de VxWorks.

./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 compiler Qt 6 à l’aide d’une compilation « shadow ». Reportez-vous à la section Options de configuration de Qt pour plus d’informations.

Une fois la configuration terminée, compilez et installez Qt 6 pour VxWorks à l’aide des commandes suivantes :

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

Plug-ins de plateforme pour les périphériques VxWorks

Qt pour VxWorks prend en charge le plugin de plateforme EGLFS pour une substitution native des fenêtres. Pour en savoir plus sur sa configuration, consultez la section EGLFS.

Compilation d’applications Qt

Pour compiler une application Qt, vous devez définir QT_VXWORKS_TOOLCHAIN_FILE en tant que variable d’environnement ou en tant que définition.

Exemple de compilation de la démo Qt « 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

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 se présenter comme suit, 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 lancer une application à l'aide de la commande VxWorks « rtpSp » :

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

Débogage d’applications Qt

Pour déboguer des applications Qt, vous devez ajouter ce qui suit à votre VSB VxWorks :

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

Ajoutez à votre configuration VIP VxWorks :

"INCLUDE_DEBUG_AGENT"
"INCLUDE_DEBUG_AGENT_START"
"INCLUDE_STANDALONE_SYM_TBL"

Depuis la ligne de commande

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

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

2. Lancez le débogueur VxWorks sur le PC :

   vxgdb <binary to debug>

3. Affichez la liste des processus en cours d'exécution dans le débogueur :

   monitor ps

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

   "attach <id from monitor>"

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

Extrait de Qt Creator

Pour déboguer à partir d’ Qt Creator, consultez Qt Creator: Débogage d’applications C++ sur des périphériques VxWorks.

Depuis Workbench

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

   

2. Définissez le VSB sur lequel le débogage est configuré.
3. Supprimez la ligne set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") du fichier CMakeLists.txt.
4. Ajoutez le code CMake lié à Qt dans le fichier CMakeLists.txt en suivant le guide « Getting started with CMake ».
5. Avant « project() », ajoutez « unset(CMAKE_TOOLCHAIN_FILE CACHE) » et ajoutez « CMAKE_TOOLCHAIN_FILE » en pointant vers le fichier de la chaîne d'outils Qt6, ainsi que « 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. Compilez le projet d’application.
7. Créez une nouvelle connexion.

   

8. Lancez le processus RTP pour déboguer.

   

9. Cliquez sur « Options avancées ».

   

10. Définissez la taille de la pile sur 0x100000.

    

Plug-ins d'entrée Qt pour VxWorks

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

VxMouse

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

VxKeyboard

VxKeyboard utilise le même schéma de configuration qu’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 une application Qt basée sur Qt Quick ou des classes telles que QOpenGLWidget. Le paramètre par défaut peut s'avérer 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 risquent de présenter des dysfonctionnements inattendus. Il est donc recommandé de s’assurer qu’au moins 128 Mo de mémoire GPU sont disponibles. Pour les systèmes ne disposant pas d’une quantité fixe de mémoire réservée au GPU, cela ne pose pas de problème.