C

Building for INTEGRITY

To use Qt Safe Renderer and its examples on target devices with Green Hills Software INTEGRITY Real-Time Operating System (RTOS), you need to build the following projects:

ProjectDescription.pro file name.pro file pathBuild with Qt version
Qt Safe Layout ToolQt Safe Layout Tool generates safe layout data for Qt Safe Renderer.qtsafelayouttool.pro<Qt Safe Renderer installation directory>/Src/QtSafeRenderer-<version>/tools/qtsafelayouttoolQt that is compiled for your host platform.
Qt Safe RendererWhen you build Qt Safe Renderer, the Qt Safe Renderer plugins are built and installed under the current kit in Qt Creator (that is, the Qt version that you use for building the projects).qtsaferenderer.pro<Qt Safe Renderer installation directory>/Src/QtSafeRenderer-<version>Qt compiled for INTEGRITY.

For INTEGRITY, Qt Safe Renderer provides the following examples:

ProjectDescription.pro file name.pro file pathBuild with Qt version
The Qt Cluster exampleQt Cluster demonstrates rendering on INTEGRITY and recovery from the main UI failure.qtcluster.pro<Qt Safe Renderer installation directory>/Examples/QtSafeRenderer-<version>/qtclusterQt compiled for INTEGRITY
The Telltales exampleWhen you build Telltales, you must use the Qt compiled for INTEGRITY. Then the INTEGRITY specific part of the project is built. The Process Watcher project is built together with the INTEGRITY specific Telltales.examples.pro<Qt Safe Renderer installation directory>/Examples/QtSafeRenderer-<version>/Qt compiled for INTEGRITY

Building Qt for INTEGRITY describes the high-level steps that are required for building Qt Safe Renderer for INTEGRITY in case your target device is either Renesas R-Car H3 or Qualcomm Snapdragon.

However, you should note that the steps assume you already have experience of working with the INTEGRITY environment. If you need more detailed information how to build Qt Safe Renderer for INTEGRITY, you can contact Qt Consulting Services.

Building Qt Safe Layout Tool

To build Qt Safe Layout Tool in Qt Creator, execute the steps listed in the following topics for qtsaferenderer.pro. Build the project with a Qt version that is compiled for your host platform. After a successful build, qtsafelayouttool is generated under <Qt installation directory>/<Qt version>/<compiler>/bin.

Opening Project to Edit Mode

Open the project to Qt Creator's Edit mode:

  1. Start Qt Creator.
  2. Select File > Open File or Project and browse to a .pro file.
  3. Select Open.
  4. In the Configure Project page, choose a kit for building the project and select Configure Project.

The project is now open in Qt Creator's Edit mode.

Adding a Custom Build Step <make install>

Note: If you are building some of the examples in Qt Safe Renderer, you can skip this step.

Before building Qt Safe Renderer, add a custom build step that installs the binary file under <Qt installation directory>/<Qt version/<compiler>/bin in the Qt version that is used for building the project:

  1. Select a Projects mode.
  2. In the kit, select Build.
  3. Select Build Settings > Build Steps > Add Build Step > Make.
  4. In Make arguments, add install.
  5. Select the Edit mode. Your custom build step is automatically saved.

Building the Project

Build the project in the Edit mode by selecting Build > Build Project "<project name>".

Building Qt for INTEGRITY

Building Qt Safe Renderer for INTEGRITY is supported with Qt 5.9.4 or later for INTEGRITY. This is due to QTBUG-62568 INTEGRITY on Renesas H3 Salvator-X that has been fixed into Qt 5.9.4.

Before you can build Qt Safe Renderer for INTEGRITY, you need to build Qt itself. The built Qt contains the qmake tool that you need for building Qt Safe Renderer for INTEGRITY.

To build Qt, you must have a properly installed INTEGRITY environment on your host platform. Also, you need an environment setup script. The INTEGRITY environment must be installed according to the Green Hills and Board Support Package (BSP) instructions provided by Renesas or Qualcomm

Setting Environment for Renesas R-Car H3

The following code provides an example of the environment setup script for the Renesas R-Car H3 target:

#!/bin/bash

export PATH=$PATH:</path/to>/comp_201714
export INTEGRITY_DIR=</path/to>/int1144
export INTEGRITY_BSP=devtree-arm64
export GL_INC_DIR=</path/to>/int1144/modules/renesas/libs/Gfx/INC:/path/to/int1144/modules/renesas/libs/wm_usr/inc/:</path/to>/int1144/modules/renesas/libs/mmgr_usr/inc/:</path/to>/int1144/modules/renesas/include/
export GL_LIB_DIR=</path/to>/int1144/modules/renesas/libs/Gfx/LIB/rcar-h3:</path/to>/int1144/bin/devtree-arm64

</path/to> is a path that points to a directory that is mentioned in the example script.

After you have sourced the environment, you can build Qt for INTEGRITY as follows:

mkdir qt-shadow
cd qt-shadow
</path/to>/qt-source/configure -developer-build -xplatform \
integrity-armv8-rcar -confirm-license -nomake examples -nomake tests \
-no-dbus -silent -opengl es2 -static
make -j10

You can find the qmake binary under qt-shadow/qtbase/bin/.

Setting Environment for Qualcomm Snapdragon

The following code provides an example of the environment setup script for the Qualcomm Snapdragon target:

export PATH=$PATH:</path/to>/comp_201714
export INTEGRITY_DIR=</path/to>/int1172
export INTEGRITY_BSP=devtree-arm64
export GL_INC_DIR=</path/to>/qc_bsp/ghs_ap/AMSS/multimedia/graphics/opengl/esx/shared/include/public
export GL_LIB_DIR=</path/to>/int1170/bin/AMSS/graphics
export QCLIBS_DIR=</path/to>/int1170/libs/qclibs
export QC_MULTIMEDIA_INC_DIR=</path/to>/qc_bsp/ghs_ap/include/amss/multimedia
export GHS_DTC=</path/to>/dtc/dtc

After you have sourced the environment, you can build Qt for INTEGRITY as follows:

mkdir qt-shadow
cd qt-shadow
</path/to>/qt-source/configure -device integrity-armv8-msm8996au -nomake examples -nomake tests -no-dbus -silent -static
make -j10

You can find the qmake binary under qt-shadow/qtbase/bin/.

Building Qt Safe Renderer and Examples

After you have built Qt for INTEGRITY, you can start Qt Creator and build the Qt Safe Renderer and its INTEGRITY specific examples, Telltales and Qt Cluster. To enable an INTEGRITY build in Qt Creator, you must set the Qt for INTEGRITY to your kit. See Adding Kits.

You can build Qt Safe Renderer, Telltales, and Qt Cluster for INTEGRITY with the same steps that are described in Building Qt Safe Layout Tool. Just remember that in Opening Project to Edit Mode, you must select the Qt for INTEGRITY kit. The kit is selected from the Configure Project page.

When you build the Telltales example, also a Process Watcher project is built.

Adding New Address Space

After you have built the Telltales example, you need to add a new address space to your working INTEGRITY project. Add the following code block to the integrated file (.int) under your project:

AddressSpace                    saferenderer
        Filename                        </path/to>/telltales
        MemoryPoolSize                  0x1000000
        Language                        C++
        Task                            Initial
                StackLength             0x20000
                StartIt                 true
        EndTask
        HeapExtensionReservedSize       0x20000
EndAddressSpace

</path/to> is the directory where the Telltales binaries are found.

Rebuild the project and run it on the target device as instructed in the INTEGRITY BSP instructions provided by Green Hills and the target device vendor (Renesas or Qualcomm).

Available under certain Qt licenses.
Find out more.