Compiler Qt avec un hôte Windows 10 Compilation et flashage d'un projet à téléchargement dynamique

Compilation de Qt pour la carte Qualcomm Snapdragon 8155P sous Windows 10

La configuration des environnements de développement Green Hills INTEGRITY et Qualcomm est indispensable avant de poursuivre. Voir Installation des dépendances de la plateforme.

Création d'un script batch pour Windows 10

Pour configurer l’environnement de développement de Qt pour INTEGRITY, compilez Qt à partir des sources destinées à la carte Qualcomm Snapdragon 8155P. Avant de compiler Qt pour INTEGRITY, configurez l’environnement de compilation. Voici un script batch permettant d’automatiser cette opération, car elle doit être effectuée avant chaque compilation.

Sous Windows 10, créez un nouveau script batch nommé setEnvironment.bat et enregistrez-le dans votre dossier personnel. Ajoutez les variables d’exportation suivantes au script :

@echo off
set PATH=%PATH%;C:\ghs\comp_202014
set INTEGRITY_DIR=C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\integrity
set INTEGRITY_BSP=platform-sa8155
set INTEGRITY_BUILD_TARGET=chk
set QC_MULTIMEDIA_INC_DIR=C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\include\amss\multimedia
set GL_INC_DIR=C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\AMSS\multimedia\graphics\include\public
set GL_LIB_DIR=C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\out\rel\libs\base;C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\out\rel\libs\multimedia\display;C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\out\rel\libs\multimedia\graphics;C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\out\rel\libs\platform\;C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot\apps\ghs_apps_proc\qc_bsp\AMSS\multimedia\graphics\opengl\esx\build\integrity\prebuilt\
set TARGET_ROOT_PATH="C:\Users\user\ghs_pack\es7_dev_env\hlos_dev_boot"

Ces chemins d’exportation supposent que vous ayez utilisé les répertoires d’installation « C:\ghs\comp_202014 and C:\Users\user\ghs_pack\* » lors de l’installation de MULTI IDE et d’INTEGRITY (voir Installation des dépendances de la plateforme). Si vous n’avez pas utilisé les répertoires par défaut, adaptez les chemins d’exportation en conséquence.

Pour initialiser votre environnement de compilation, exécutez la commande suivante dans un terminal CMD Windows :

setEnvironment.bat

Remarque : exécutez cette commande dans le terminal CMD de Windows chaque fois que vous compilez Qt ou que vous utilisez les systèmes de compilation qmake ou CMake.

Obtenir les sources de Qt

Vous pouvez télécharger le code source de Qt depuis votre compte Qt.

Vous pouvez également récupérer les sources de Qt à partir du dépôt Git ; consultez la section « Obtenir le code source ».

Remarque : la version des sourcesQt doit être 6.2 ou ultérieure.

Remarque : les modulesQt pris en charge par Qt for INTEGRITY sont répertoriés dans la section « Modules Qt pris en charge ».

Compilation de Qt Desktop pour l'utilisation d'outils de compilation croisée

La compilation croisée de Qt nécessite la présence d’une version de Qt compilée sur l’hôte. Au cours de la compilation, des outils tels que moc, rcc, qmlcachegen, qsb et d’autres sont appelés à partir de cette version. Pour plus d’informations, veuillez consulter la section « Compilation croisée de Qt ».

Exécutez les commandes suivantes pour la compilation hôte sous Windows 10 :

mkdir hostbuild
cd hostbuild/
C:/Users/user/qt5/configure -nomake tests -nomake examples -release -prefix C:/Users/user/hostbuild
cmake --build . --parallel 6
cmake --install .

Création d'un fichier de chaîne d'outils pour INTEGRITY

Pour effectuer une compilation croisée d'un projet avec CMake, il faut spécifier un fichier de chaîne d'outils. Ce fichier, rédigé en langage CMake, définit les valeurs appropriées pour le nom de la plate-forme, le compilateur/éditeur de liens utilisé, ainsi que toute une série d'autres paramètres spécifiques à la chaîne d'outils. Pour la version d'Integrity sous Windows 10, créez un fichier toolchain.cmake contenant les informations suivantes :

# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

#generic
set(CMAKE_SYSTEM_NAME Integrity)
set(CMAKE_SYSTEM_PROCESSOR arm)
set(CMAKE_CROSSCOMPILING True)

#path to installed GHS compiler for WIN10
set(TARGET_ROOT_PATH "C:/Users/user/ghs_pack/es7_dev_env/hlos_dev_boot")
set(CMAKE_BUILD_TYPE "Release")

set(GHS_COMPILER C:/ghs/comp_202014/cxintarm64.exe)
set(CMAKE_C_COMPILER ${GHS_COMPILER})
set(CMAKE_CXX_COMPILER ${GHS_COMPILER})
set(CMAKE_ASM_COMPILER ${GHS_COMPILER})

set(EGL_FOUND True)
set(UNIX True)

set (CMAKE_C_COMPILE_FEATURES c_std_99)
set (CMAKE_CXX_COMPILE_FEATURES
cxx_alias_templates
cxx_alignas
cxx_alignof
cxx_attributes
cxx_auto_type
cxx_constexp
cxx_decltype
cxx_delegating_constructors
cxx_explicit_conversions
cxx_extern_templates
cxx_inheriting_constructors
cxx_lambdas
cxx_noexcept
cxx_nonstatic_member_init
cxx_nullptr
cxx_override
cxx_range_for
cxx_raw_string_literals
cxx_reference_qualified_functions
cxx_rvalue_references
cxx_static_assert
cxx_std_17
cxx_thread_local
cxx_unicode_literals
cxx_uniform_initialization
cxx_unrestricted_unions
cxx_variadic_macros
cxx_variadic_templates)

if (NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
endif()
if (NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
endif()
if (NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
endif()
if (NOT DEFINED CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()

set(CMAKE_FIND_ROOT_PATH ${TARGET_ROOT_PATH})

#base
set(CMAKE_C_FLAGS  "-bsp $ENV{INTEGRITY_BSP} -os_dir $ENV{INTEGRITY_DIR} -non_shared -startfile_dir=$ENV{INTEGRITY_DIR}/libs/$ENV{INTEGRITY_BSP}/$ENV{INTEGRITY_BUILD_TARGET} --rtos_library_directory=libs/$ENV{INTEGRITY_BSP}/$ENV{INTEGRITY_BUILD_TARGET} --rtos_library_directory=libs/arm64/$ENV{INTEGRITY_BUILD_TARGET} -bigswitch -DINTEGRITY -llibposix.a")
set(CMAKE_C_FLAGS_DEBUG "-g -Omaxdebug")
set(CMAKE_C_FLAGS_RELEASE "-Ospeed -Olink -Omax -no_uvfd")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --signed_fields --diag_suppress=1,82,228,236,381,611,961,997,1795,1931,1974,3148 --c++17 --thread_local_storage --exceptions --defer_parse_function_templates")

set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -frigor=accurate --signed_fields --no_implicit_include --link_once_templates -non_shared --new_outside_of_constructor --commons -I $ENV{QC_MULTIMEDIA_INC_DIR}")
set(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")

set(CMAKE_FIND_LIBRARY_PREFIXES "lib")
set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")

set(BUILD_SHARED_LIBS OFF)
set(QT_CFLAGS_OPTIMIZE_FULL "-Ospeed -Olink -Omax -no_uvfd")

set(EGL_INCLUDE_DIR $ENV{GL_INC_DIR})
set(PKG_EGL_LIBRARY_DIRS ${TARGET_ROOT_PATH})

set(GLESv2_INCLUDE_DIR $ENV{GL_INC_DIR})
set(OPENGL_INCLUDE_DIR $ENV{GL_INC_DIR})

set(EGL_LIBRARY "${EGL_LIBRARY_GRAPHIC_PATH}/libESXEGL_Adreno.a")

set(GLESv2_INCLUDE_DIR $ENV{GL_INC_DIR})
set(GLESv2_LIBRARY "${EGL_LIBRARY_GRAPHIC_PATH}/libESXGLESv2_Adreno.a")

set(IntegrityPlatformGraphics_INCLUDE_DIR ${GL_INC_DIR})
set(IntegrityPlatformGraphics_LIBRARY "${EGL_LIBRARY_GRAPHIC_PATH}/libadreno_utils.a")
set(IntegrityPlatformGraphics_LIBRARIES_PACK
    "${EGL_LIBRARY_BASE_PATH}/libplanedef.a"
    "${EGL_LIBRARY_BASE_PATH}/libmmosalfile.a"
    "${EGL_LIBRARY_BASE_PATH}/libOSAbstraction.a"
    "${EGL_LIBRARY_OPENWFD_PATH}/libopenwfd.a"
    "${EGL_LIBRARY_GRAPHIC_PATH}/libOSUser.a"
    "${EGL_LIBRARY_GRAPHIC_PATH}/libpanel.a"
    "${EGL_LIBRARY_GRAPHIC_PATH}/libGSLUser.a"
    "${EGL_LIBRARY_PREBUILD_PATH}/libglnext-llvm.a"
    "${EGL_LIBRARY_PLATFORM_PATH}/libpmem.a"
    "${EGL_LIBRARY_CHK_PATH}/libposix.a"
    "${EGL_LIBRARY_CHK_PATH}/libivfs.a"
)

list(APPEND _qt_igy_gui_libs
    "${GLESv2_LIBRARY}"
    "${IntegrityPlatformGraphics_LIBRARY}"
    "${IntegrityPlatformGraphics_LIBRARIES_PACK}")

set(OPENGL_opengl_LIBRARY ${EGL_LIBRARY})

# Command is required to fix CMake WIN bug https://gitlab.kitware.com/cmake/cmake/-/issues/22933
set(CMAKE_CXX_COMPILER_PREDEFINES_COMMAND ${CMAKE_CXX_COMPILER})
list(APPEND CMAKE_CXX_COMPILER_PREDEFINES_COMMAND -bsp $ENV{INTEGRITY_BSP} -os_dir $ENV{INTEGRITY_DIR} -E -dM "${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp")

# Set format for creating static library
set(CMAKE_CXX_CREATE_STATIC_LIBRARY "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS} <LINK_FLAGS> -archive -o <TARGET> <OBJECTS> -keep_objs")
set(CMAKE_C_CREATE_STATIC_LIBRARY   "${CMAKE_CXX_COMPILER} ${CMAKE_C_FLAGS} <LINK_FLAGS> -archive -o <TARGET> <OBJECTS> -keep_objs")

# Set format to create executables
set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
set(CMAKE_C_LINK_EXECUTABLE   "${CMAKE_CXX_COMPILER} ${CMAKE_C_FLAGS} <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")

Configuration de Qt pour INTEGRITY

Configurez Qt pour la carte Qualcomm Snapdragon 8155P à l’aide des commandes suivantes : « Windows 10 HOST » nécessite la ligne de configuration suivante :

mkdir targetbuild
cd targetbuild/
cmake C:/Users/user/qt5/ -DQT_HOST_PATH=/c/Users/user/hostbuild/qtbase
-DCMAKE_TOOLCHAIN_FILE=/c/Users/user/ghs_pack/es7_dev_env/hlos_dev_boot/toolchain_integrity.cmake
-DQT_QMAKE_TARGET_MKSPEC=devices/integrity-armv8-SA8155P
-DBUILD_qtdoc=OFF -DBUILD_qttranslations=OFF -DFEATURE_printdialog=OFF --debug-trycompile -DFEATURE_dbus=OFF
-DFEATURE_dnslookup=OFF -DFEATURE_glib=OFF -DFEATURE_system_pcre2=OFF -DFEATURE_sql_mysql=OFF
-DQT_FEATURE_harfbuzz=OFF -DFEATURE_pkg_config=OFF -DUNIX=ON -DCMAKE_HOST_WIN32=ON -GNinja -DCMAKE_INSTALL_PREFIX=/c/Users/user/targetbuild/

Remarque : INTEGRITY ne prend en charge que les versions statiques de Qt.

Remarque : la variableQT_HOST_PATH a été introduite dans Qt 6. Lors d'une compilation croisée, elle doit être définie sur le chemin d'installation de Qt pour la plate-forme hôte. Elle sert à localiser les outils à exécuter sur l'hôte (moc, rcc, androiddeployqt, etc.).

Compilation de Qt pour INTEGRITY

Compilez Qt en exécutant la commande ` cmake ` dans le terminal. Vous pouvez exécuter ` cmake ` en utilisant autant de cœurs que vous le souhaitez sur votre machine hôte. Dans notre exemple, nous utilisons six cœurs :

cmake --build . --parallel 6

Installation de Qt

Si vous n'avez pas utilisé l'option de configuration ` -prefix $PWD/qtbase ` décrite dans la section « Configuration de Qt », exécutez les commandes suivantes dans un terminal :

cd <Qt installation directory>
cmake --install .

Si vous avez utilisé l'option de configuration « -prefix $PWD/qtbase », vous pouvez utiliser Qt à partir du répertoire de compilation, sans exécuter la commande « cmake install ».

Qt est désormais configuré et compilé pour la carte sa8155.

Compiler Qt sur un hôte Windows 10 Compilation et flashage d'un projet Dynamic Download

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.