Back to Blog home

Announcing the Qt Automotive Suite 5.13

Published on Friday June 28, 2019 by Miao Luo in Automotive Biz Circuit Functional Safety Dev Loop Biz Circuit & Dev Loop | Comments

We’re elated to announce the latest edition of our Qt Automotive Suite 5.13, a unified HMI toolchain and framework for building the next generation of digital cockpits.

Three years ago, we introduced the Qt Automotive Suite to solve key challenges in creating HMIs for digital cockpits in automobiles [1][2][3]. Qt Automotive Suite offers a unique end-to-end HMI solution with a single technology: combining world class tooling and automotive-specific software HMI components, with Qt optimized for embedded devices,

In this release, we focused on a few selected areas to improve and expand the offering. In the market, we continue to see steady adoption of our technology by top OEMs and Tier 1 suppliers around the world. We will see volume production of vehicles powered by the Qt Automotive Suite rolling out as early as 2020.

The Base

Qt Automotive Suite 5.13 is based on the new Qt 5.13 and sits on top of its embedded offering - Qt for Device Creation. Qt 5.13 brings new features, updates, bug fixes, and other improvements. For more information, refer to the official release announcement at: https://www.qt.io/blog/2019/06/19/qt-5-13-released/.

We have also improved the tooling to make designing, developing, and deploying software with Qt more efficient for designers and developers. One such improvement is via Qt 3D Studio. With the version 2.4 release, Qt 3D Studio and its runtime is another component for the Qt Automotive Suite.

Here’s an example of a full 3D Instrument Cluster to show you what’s possible with Qt 3D Studio:

e399f866707281-5b3e093981ba1 Instrument cluster built with Qt 3D Studio by Siili Solution (For more details, see https://www.behance.net/gallery/66707281/QT-Altair)

The Components

Our Reference UI, Neptune 3 UI, can now use Qt 3D Studio and its runtime to render 3D content. It’s also possible to switch between the new implementation based on the Qt 3D Studio Runtime and the previously available implementation based on Qt3D, which is still the default selection. This new scene loads assets directly from a Qt 3D Studio project, simplifying the task of incorporating changes from designers. The implementation still supports the existing “remote control” features to move some objects in the 3D scene with simple QML statements. We use this type of feature to control car doors, sunroof, and the trunk of our 3D car model. Additionally, all of the APIs for the UI have been retained.

We optimized the 3D car model itself to improve its loading time. It's possible to switch between three levels of complexity in the model, for optimal use of hardware capabilities. The UI controls for all these new switches are provided in the new “3D options” panel, in the Vehicle app.

And we’re still not done with 3D just yet! In addition to the existing 2G gauges, the Neptune 3 UI cluster can now use the Qt 3D Studio runtime as well, with its own Qt 3D Studio-designed content. You can also switch between the 2D and 3D implementation.

qt-auto-cluster-animated

The new 3D gauges and 3D car model follow the color accent set in the General Settings.

3d_runtime_selection_in_neptune 3D runtime options between Qt 3D and Qt 3D Studio

qt-auto-central-stack-animated All applications follow the color theme managed by System UI

The cluster UI now integrates with Qt Safe Renderer. This integration is focused on the development aspects, hence we have added some "tricks" to improve the developer productivity in these use cases – even using standard hardware, that typically doesn’t provide safe rendering. On the desktop, we use a separate application with its own top-level window that renders content using Qt Safe Renderer. This window is placed underneath the cluster window. If the Neptune 3 UI process stops or crashes, this Qt Safe Renderer window remains on the desktop and keeps rendering, fetching the values from the new Vehicle Data service. On embedded targets, we have a separate process that takes over the rendering if Neptune 3 UI, as the main UI, stops working. This implementation leverages all parts of the Qt Safe Renderer 1.1.

We promote development of automotive and embedded HMI in separate apps running as multiple processes. In this release, we improved the application installation in Neptune 3 UI. It now uses a new configuration as the applications are not saved in the temporary folder anymore. In the System Dialog, the application control has been extended to provide controls and settings for life cycle states. It’s now possible to define which applications should be launched automatically on startup and which ones should be relaunched if they stop, in the event of a crash.

neptune_apps System UI Apps configuration

If you look at the list of applications, you may notice that most of Neptune 3 UI now consist of separate applications. You can stop all of them, if necessary. Most importantly, this improvement makes it possible for you to develop and test each part separately and independently; even across different teams.

In our previous release, we introduced the UI harness, whereas with this release, Neptune 3 UI introduces new wrappers that allow developers to run these harnesses directly from Qt Creator; but you can also run these wrappers independently. There are two harnesses provided for reference: a cluster harness and a vehicle harness. If you run the cluster harness, it starts the cluster independently in QML Live, depending on whether QML live is available or not. Otherwise, the cluster runs with “qmlscene”. The harness is a key differentiator as it illustrates how our architecture allows part of Neptune 3 UI to be decomposed and run separately, using the same code base as when it runs completely.

We mentioned the new Vehicle Data service above. In this release, we introduced it an additional out-of-process service, based on our old Remote Settings Server. This is a key improvement in the middleware infrastructure, which is now more tailored to the use of out-of-process services.

While Neptune 3 UI runs, the values displayed in the cluster are simulated to change on their own. This is a nifty feature for demos, but is also very useful in day-to-day development. It helps HMI developers test the implementation in various states of the business logic. The simulation is powered by the Simulation Engine introduced in the last release, as part of Qt IVI. Just like the Neptune 3 UI, this simulation is written in QML. In this architecture, the Vehicle Data service is actually a fully autogenerated simulation server, that feeds data to the HMI via the same API as a real middleware service. The QML code running this simulation can model the business logic of many real life use cases. This is beneficial for HMI development, particularly in the early prototyping phase and other development phases.

The Simulation Engine in Qt IVI has also been extended to support the new middleware infrastructure. This includes the use of Qt Remote Objects as a transport layer. In combination with the auto-generated code, the new middleware infrastructure provides a complete environment for HMI development separated from the middleware development.

Improvements in the middleware infrastructure also include a revamped Companion app. Initially developed for testing, it’s now provided with Neptune 3 UI as a new app. This app implements a popular automotive use case: an in-vehicle companion app that runs on a mobile device and directly connects to the head unit. The app has an improved UI which is closer to real-world use cases.

qt-auto-companion-animated Companion mobile app

The Companion app uses the same API for middleware as Neptune 3 UI itself. Both the API and backend plugins are shared, which saves both time and effort.

Last, but not least, Neptune 3 UI now uses Qt Application Manager’s Intent Management, introduced in the last release. This feature is used to switch between the music sources: the Tuner and the Media Player.

The Tools

We have released version 2.11.0 of GammaRay; our Qt application monitoring tool. GammaRay allows you to observe the behavior and data structures of Qt code inside your program live at runtime.

GammaRay 2.11.0 includes a new inspection tool for Qt's event handling, providing deeper insights into the inner workings of your application. Apart from analyzing the events and their properties as they occur, the event monitor visualizes event propagation during input handling, as it happens for both Qt Quick or Qt Widgets.

gammaray-event-monitor-log

Additionally, the event monitor now provides statistics on how often which type of event occurred, as well as fine-grained filtering options to drilldown into events that may interest you , even in a huge dataset.

gammaray-event-monitor-types

One major new feature is the network operation inspector, that allows you to observe the HTTP operations triggered via QNetworkAccessManager and helps you to optimize network interactions, identify QNetworkReply objects that may have leaked, and ensure that all operations are encrypted.

gammaray-network-operations-monitor

GammaRay 2.11.0 now supports more data types, like the QJson* classes, a new thread affinity checker for the problem reporter, as well as compatibility with the newly released Qt 5.13. Under the hood, we’ve also done some performance improvements, particularly improving GammaRay’s responsiveness when inspecting large and/or busy applications.

QML Live is both, a local and a remote Qt Quick live reloading system that allows you to change your QML UI source code and view the result in real time.

qml_live QML Live in action

In this release, QML Live supports multi-process rendering. This is a substantial change, that lets you start multiple runtimes to observe changes in more than one top-level HMI view.

We have also resumed active development of the Qt Creator plugin for Qt Application Manager. In addition to the internal improvements, the plugin now has a simplified UI and a bit more automation, to reduce the number of configuration steps.

Documentation

In this release, we‘ve invested significant effort into improving and rewriting large parts of our documentation. We’ve tried to focus on explaining the key concepts and approaches that we use, with the hope that this content fills in the gaps and aids new users to connect the dots: https://doc.qt.io/QtAutomotiveSuite/index.html.

Looking Ahead

We are looking to add hardware cursor key navigation, provide a basic support for voice assistants, support background application services, bundle packages, integrate the Deployment Server into the workflow in Qt Creator, and also automatically populate the Deployment Server with apps from a specific repository.

Furthermore, we continue to improve support for multi-domain architecture on a single SoC, embracing webOS, Android Automotive OS, AGL, GENIVI and bringing inter-domain interactivity on top

cockpit_design_siili Digital cockpit by Siili Solution (https://www.behance.net/gallery/79438455/Enhancing-the-driving-experience)

Summary

With Qt Automotive Suite 5.13, we’ve made more steps towards our goal: unleash the power of Qt to make the development of appealing UX easy and fast. We want to help our customers to transform their visions and concepts into HMIs that you can experience at car dealerships near you.

One of these days you might see the next version of this appealing prototype made with Qt:

e-legend-interior-banner-455778-18 Peugeot E-Legend digital cockpit (https://www.peugeot.co.uk/concept-cars/e-legend/)

Finally, big thanks for our partners, KDAB and Luxoft, for the great collaborative work and contributions. We are also very grateful to our customers and prospects for their continuous feedback and open discussions.

If you have questions about Qt Automotive Suite, fell free to contact us.

Subscribe to Our Blog

Stay up to date with the latest marketing, sales and service tips and news.