Qt para VxWorks

Si desea más información, póngase en contacto con The Qt Company: https://www.qt.io/contact-us/

Licencias de Qt para VxWorks

Qt para VxWorks está disponible bajo la licencia Qt for Device Creation Professional (DCP). Para obtener más información, consulte Precios de Qt.

Arquitecturas y versiones de VxWorks soportadas

Qt 6.10 está verificado en VxWorks 25.03.

Arquitecturas compatibles:

• ARM-v7-Probado en BD-SL-i.MX6. BSP utilizado: fsl_imx6
• x86_64-Probado en Intel NUC6i3SYH. BSP utilizado: itl_generic

Si está interesado en versiones posteriores de Qt, póngase en contacto con los servicios profesionales de Qt.

Requisitos para VxWorks

Qt Widgets Aplicaciones

• Soporte POSIX
• Compatibilidad con C++17

Qt Quick 2 Aplicaciones

Todas las funciones necesarias para las aplicaciones de Qt Widgets y, además, las siguientes:

• Dispositivo GPU (GPUDEV) para OpenGL ES 2.0

Módulos compatibles

Se soportan la mayoría de los módulos esenciales de Qt y algunos módulos adicionales.

Módulos esenciales compatibles

Complementos compatibles

Notas sobre la plataforma

Qt está preparado para ser utilizado por aplicaciones RTP, no hay soporte para DKM.

Con el lanzamiento de Qt 5.0, Qt ya no contiene su propia implementación del sistema de ventanas: QWS ya no es una plataforma soportada. Para casos de uso de un solo proceso, la Abstracción de Plataforma Qt es una solución superior.

Hay un plugin que es utilizable en VxWorks: EGLFS. La disponibilidad de este plugin depende de la configuración de Qt.

Configuración para un dispositivo específico

Prepare su entorno instalando el SDK de VxWorks y obteniendo la licencia de WindRiver que necesita el instalador y para crear imágenes de VxWorks. Busque el instalador apropiado en {https://gallery.windriver.com/portal/products}.

La compilación de Qt para un dispositivo determinado requiere una instalación de Qt 6 para el host de compilación, un toolchain y un sysroot. Ver Compilación cruzada de Qt para más detalles. Además, algunos dispositivos requieren código de adaptación específico del fabricante para la compatibilidad con EGL y OpenGL 2.0.

Requisitos de imagen de VxWorks

Qt para VxWorks requiere que ciertos paquetes de imágenes y componentes de VxWorks estén incrustados en el software base para que Qt compile y funcione correctamente. La lista no es en absoluto completa, ya que depende de los requisitos de hardware, software y sistema de su proyecto. Sin embargo, la siguiente tabla contiene aquellos que son obligatorios para que ciertas funcionalidades funcionen (incluyendo el soporte de pantalla táctil). Tenga en cuenta también que estos pueden cambiar con las versiones de VxWorks.

Ejemplo de configuración VSB para los BSPs fsl_imx6 e itl_generic

Es necesario añadir las siguientes características a VSB para que Qt funcione correctamente. Para más detalles, consulte la documentación de WindRiver VxWorks.

Las siguientes variables de configuración se añaden implícitamente y es necesario eliminarlas:

Debe añadir las siguientes variables a la configuración:

Ejemplo de configuración VIP para los BSP fsl_imx6 e itl_generic

Para más detalles, consulte la documentación de WindRiver VxWorks.

Los siguientes componentes se añaden implícitamente y es necesario eliminarlos:

Parámetros VIP

Es necesario añadir los siguientes parámetros para que Qt funcione correctamente en VxWorks:

Construyendo Qt 6 para VxWorks

Compilación del host

Es necesario disponer de una compilación host de Qt para poder realizar la compilación cruzada de Qt. Esto se debe a que, durante la compilación, ciertas herramientas (como moc, rcc, qmlcachegen, y qsb) son invocadas desde la compilación host. Tienes las siguientes opciones:

• Construir Qt Sources para el host,
• Instalar la compilación del host usando Qt Online Installer.

Sin embargo, es aconsejable asegurarse de que se puede compilar Qt para el escritorio en el host también, ya que las mismas herramientas son también necesarias cuando se compila para VxWorks.

Ejecutar el script de configuración

Los comandos para configurar, compilar e instalar Qt 6 para host son los siguientes:

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

Estos comandos instalan Qt 6 para el host en <path_to_Qt 6_host_installation_dir>.

Construyendo Qt 6 para el Target

Configuración del entorno de compilación

Antes de ejecutar la configuración y compilación de Qt 6, debe abrir VxWorks Development Shell en el símbolo del sistema.

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

Preparación del archivo CMake Toolchain personalizado

Para incluir librerías gráficas desde el BSP, primero necesitas crear un archivo CMake toolchain. Un ejemplo de archivo CMake toolchain para el dispositivo 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 ejemplo para 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)

Ejecutando Qt 6 Configure para el Target

A continuación se muestra un ejemplo de configuración para la BD-SL-i.MX6. Para la mayoría de las placas VxWorks el comando configure es muy similar. Por defecto, Qt 6 está configurado para usar librerías compartidas. Para compilar Qt 6 estáticamente, añada la opción -static a configure.

Asegúrese de que la variable de entorno {WIND_CC_SYSROOT} está establecida en el directorio raíz 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> \

Se recomienda compilar Qt 6 usando una shadow build. Ver Opciones de configuración de Qt para más información.

Después de la configuración, compile e instale Qt 6 para VxWorks con estos comandos:

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

Plugins de plataforma para dispositivos VxWorks

Qt para VxWorks soporta el plugin de plataforma EGLFS para una sustitución nativa de ventanas. Lee más sobre su configuración en EGLFS.

Construyendo Aplicaciones Qt

Para construir una aplicación Qt, debes establecer QT_VXWORKS_TOOLCHAIN_FILE como una variable de entorno o como una definición.

Un ejemplo para construir la demo de relojes Qt:

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

Estableciendo variables de entorno

Establezca las variables de entorno en una secuencia de comandos de inicio como se indica a continuación, por ejemplo:

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

El archivo kms.conf para el dispositivo Intel KabyLake puede tener este aspecto, por ejemplo:

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

Ejecución de aplicaciones Qt

El siguiente ejemplo muestra cómo iniciar una aplicación utilizando el comando rtpSp de VxWorks:

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

Depuración de aplicaciones Qt

Para depurar Aplicaciones Qt, debe agregar lo siguiente a su VxWorks VSB:

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

A su configuración VxWorks VIP agregue:

"INCLUDE_DEBUG_AGENT"
"INCLUDE_DEBUG_AGENT_START"
"INCLUDE_STANDALONE_SYM_TBL"

Desde la Línea de Comandos

1. Inicie la aplicación a depurar en el dispositivo a través de SSH o la conexión serie USB:

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

2. Inicie el depurador VxWorks en el PC:

   vxgdb <binary to debug>

3. Listar los procesos en ejecución en el depurador:

   monitor ps

4. Adjuntar el depurador a la aplicación ya en ejecución:

   "attach <id from monitor>"

5. Usar comandos GDB para depurar.

Desde Qt Creator

Para depurar desde Qt Creator, consulte Qt Creator: Depuración de aplicaciones C++ en dispositivos VxWorks.

Desde Workbench

1. Cree un proyecto CMake Real Time Process.

   

2. Establecer el VSB que tiene la depuración configurada.
3. Eliminar set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") de CMakeLists.txt.
4. Añade el código relacionado con Qt CMake al CMakeLists.txt siguiendo Getting started with CMake.
5. Antes de project() añadir unset(CMAKE_TOOLCHAIN_FILE CACHE) y añadir CMAKE_TOOLCHAIN_FILE apuntando al archivo toolchain de Qt6 y QT_CHAINLOAD_TOOLCHAIN_FILE al archivo toolchain de VSB. Por ejemplo:

   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. Construir el Proyecto de aplicación.
7. Crear una Nueva Conexión.

   

8. Inicie el proceso RTP para depurar.

   

9. Haga clic en Opciones avanzadas.

   

10. Establecer el tamaño de la pila a 0x100000.

    

Plugins de entrada de Qt para VxWorks

VxWorks utiliza su propia implementación de libevdev, que tiene una API muy similar a la de Linux, pero difiere en capacidades. Debido a esto Qt implementa plugins de entrada separados para VxWorks para manejar ratón, teclado y pantalla táctil, que están basados en {inputs-linux-device.html}{Linux evdev}, con diferencias que se explican a continuación.

VxMouse

VxMouse utiliza el mismo esquema de configuración que EvdevMouse, excepto por una variable de entorno diferente: QT_QPA_VXEVDEV_MOUSE_PARAMETERS. Además, VxMouse ignora los parámetros nocompress, dejitter y grab.

VxKeyboard

VxKeyboard utiliza el mismo esquema de configuración que EvdevKeyboard, excepto por una variable de entorno diferente: QT_QPA_VXEVDEV_KEYBOARD_PARAMETERS.

VxTouch

VxTouch utiliza el mismo esquema de configuración que EvdevTouch, excepto por las diferentes variables de entorno:

• QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS
• QT_QPA_VXEVDEV_DEBUG

Además, VxTouch añade dos nuevos parámetros:

Limitaciones

Memoria de vídeo

Los sistemas con una cantidad fija de memoria de vídeo dedicada pueden necesitar un cuidado extra antes de ejecutar aplicaciones Qt basadas en Qt Quick o clases como QOpenGLWidget. La configuración por defecto puede ser insuficiente para este tipo de aplicaciones, especialmente cuando se muestran en una pantalla de alta resolución (por ejemplo, Full HD). En este caso, podrían empezar a fallar de forma inesperada. Por lo tanto, se recomienda asegurarse de que hay al menos 128 MB de memoria GPU disponible. Para los sistemas que no tienen una cantidad fija de memoria reservada para la GPU esto no es un problema.