Complete Tool Suite for Rapid HMI Design & Development
Design and develop your automotive HMI quicker than ever before with our complete tool chain for creating graphical user interfaces for distributed embedded systems.
Mecel Populus Suite is a complete tool chain for designing, developing and deploying user interfaces for distributed embedded systems. It minimizes the time and cost of producing eye-catching, full-featured HMI’s (Human Machine Interfaces).
Mecel Populus Suite has several unique features. These features, when combined, remove the barriers that traditionally exist between the people working with requirements, system engineering, HMI design and implementation.
Mecel Populus Architecture
Mecel Populus Suite is built upon a concept called Database Driven Human Machine Interface. Mecel Populus Editor is used to create the entire HMI layout and HMI logic in an XML database. It is also used to specify the functional interfaces to the applications that are part of the system. These applications are called Functional Units.
An HMI is created and verified in Mecel Populus Editor without having to write any software. The HMI is stored in a database and downloaded to the target environment in a binary format for improved efficency. The HMI database contains all of the HMI logic and appearance. Mecel Populus Engine executes the HMI in run-time and communicates with the applications using the Open Display Interface protocol. The software needed for supporting this protocol can be automatically generated for the applications from the Populus Editor.
Mecel Populus Editor
The Editor supports team collaboration and reuse of HMI parts between projects. An HMI can be divided into parts of any granularity and every part is a stand-alone unit which can be re-used by other HMIs as well. The HMI design can be done directly within Mecel Populus Editor.
Mecel Populus is a tool chain that covers the entire development process from creating a system HMI architecture all the way to developing a series production HMI ready to be downloaded to the embedded target.
Mecel Populus has been designed for the automotive industry to deliver high-performance user interfaces with a short time-to-market and to enable efficient software life cycle management.
Mecel Populus Editor is used for several different tasks:
- Specifying application interfaces
- Specifying the entire HMI, both the graphical layout, visual effects and all HMI logic
- Specifying all text for all languages that will be supported
- Specifying the priority management used for the display
- Verifying the contents of the databases
- Converting the HMI database to a binary format
- Debugging the HMI
- Importing 3D Models
- Simulating missing system components
Mecel Populus Engine
Mecel Populus Engine is the run-time software component that interprets the HMI database. It receives user input, communicates with the applications and generates the graphical user interface on the display.
The optimized design of the engine software together with the effective format of the binary database produces a very fast user interface with instant start-up. Mecel Populus supports using multiple Graphics Engines at the same time, e.g. Open GL ES and Open VG.
Mecel Populus Engine comes in two variants, a light-weight 2D version and a full blown 3D version. The 3D version is capable of rendering animated 3D scenes within a regular 2D HMI but also full 3D HMI’s.
- Open GL
- Open GL ES 1.1
- Open GL ES 2.0
- Open VG 1.1
- Renesas Dave/Ravin
- Fujitsu Pixel Engine
Open Display Interface
The communication protocol used between the applications and the various Mecel Populus Engines driving the displays in the system and is called Open Display Interface (ODI). ODI is optimized for effieciency. It has been designed to decouple the Functional Units from the HMI, make them unaware of the number of displays that exist in the system and also of where the displays are located. This makes it possible for a Functional Unit to be located in the same ECU, in another ECU within the system or even on the internet and still appear completely integrated.
Functional Unit (FU) SDK
For every Functional Unit that interfaces with the HMI, a C/C++, Java or Python interface can be automatically generated. This takes care of implementing the ODI protocol, making the Functional Units unaware of all the details of the ODI protocol. This speeds up the development of the Functional Units, enhances the quality of the software and minimizes the risk of introducing errors in the communication protocol.
HMI in a database
All of the details of the HMI are stored in an HMI database. This database controls every aspect of the HMI for a specific display:
- Priority handling
- User input
- Traversal between HMI screens
- HMI Layout
- 2D and 3D Graphics
- Animations and visual effects
- Text entries for all languages
- Engineering unit formatting
- HMI states
- Triggering of external actions sent to Functional Units
- Displaying and formatting FU data
This is possible since all FU data and events are part of the database. All text entries that can be displayed for all supported languages are also part of the database. They can be edited using the Language Editor or imported from other tools.
HMI verification with the press of a buttonSince the entire HMI layout and logic as well as the interfaces to the Functional Units and all text entries are available to Mecel Populus Editor, it is possible to verify the HMI database in the tool to ensure its correctness. Example of what is verified includes:
- All references are valid
- Mandatory data is set
- There are no invalid values (e.g. out of range)
- Data from applications are used in a correct HMI context
- Formatting of numeric data is compatible with the type of data used
- All text entries exist for all supported languages
- All text entries fit within their designated area
This kind of HMI-level verification is not possible using a traditional software development approach without actually testing and debugging the running program. Verifying everything in run-time is a very time-consuming task and it is often difficult to force the software to all necessary states. With Mecel Populus this is possible just by running the verification in the editor.
Ideally suited for connectivity
Mecel Populus offers multiple ways to integrate new applications into the HMI. The simplest being to offer a viewport to an application, i.e. a part of the screen where it may render its own graphics under the supervision of Mecel Populus.
The use of ODI also enables another option for connecting to the dynamic world of cloud-based services. By implementing a simple wrapper Functional Unit it is possible to create vehicle-adapted interfaces to popular and even future Internet-based applications. As soon as a new must-have service appears, a wrapper FU in the brand portal (or on the smartphone) and an updated HMI database is all it takes to create new value for the user. These applications will not only look completely integrated with the specific vehicle HMI, but will also remain under the control of the HMI designer through Mecel Populus. We refer to this as controlled openness, a condition for a safe and distraction-free driver workplace in the future.