We put time on your side
superior validation for your overall system

superior validation for your overall system

Chrona Validator

customer benefits

The Chrona Validator provides platform-aware SIL (Software-in-the-Loop) simulations. Thus, Chrona's Validator offers the advantages of SIL simulations in terms of cost and simulation speed as well as the advantages of Hardware-in-the-Loop (HIL) simulations in terms of accuracy.

save costs by detecting bugs/errors earlier

Conventional SIL testing does not consider platform and timing aspects and thus errors and bugs are overlooked at that stage in the development process. With platform-aware SIL as offered by Chrona's Validator you reduce the development and testing effort by at least 30% because you find errors and bugs significantly earlier in the development and test process.

ISO26262 compliance without extra costs

This standard requires that "the test environment for software unit testing shall correspond as closely as possible to the target environment". That is exactly what the Chrona Validator provides.

Thus, you avoid the tedious extra effort required by ISO26262: "[otherwise, that is, in case the test and target environments do not correspond] the differences in the source and object code, and the differences between the test environment and the target environment, shall be analysed".

better quality of embedded systems

Chrona's Validator represents the most stringent test environment at that stage in the development and test process. Platform-aware SIL increases the likelihood of finding more bugs and errors, also subtle ones, because developers can harness the advanced debugging features offered by Chrona's Validator.

smooth migration towards model-based development

Chrona's Validator supports model-based extensions of legacy C applications. The model of a new controller can be first simulated together with the plant model in MATLAB®/Simulink®, in closed-loop with the legacy control software. Then the C code of the new controller, generated for example with the Embedded Coder®, can be integrated with the legacy application and the resulting overall software and system can be tested.

minimal overhead allows fast simulations

So-called instruction-set simulators would offer an alternative approach to validate embedded systems, but they are very slow and tedious. As Chrona's Validator is based on a platform abstraction, its simulations are much faster.

potential stream-lining of your tool suite (= fewer tools)

The Chrona Validator integrates with your test case management tool of choice. In this usage scenario the Chrona Validator is "under the hood", but still offers the advantages of a more reliable SIL testing. In other words, developers do not need to learn how to work with an additional tool.

State-of-the-art test case management tools allow you to specify test cases once and test in MIL (model-in-the-loop), SIL and HIL settings. Overall, the introduction of Chrona's Validator together with a modern test case management tool might help to streamline your tool suite.

incremental set-up: start small ...

Chrona's Validator requires a platform model and the execution timing information of code fragements. To avoid delays and costs before being able to use Chrona's Validator, you typically start with a coarse-grained, rudimentary platform model which you incrementally refine. For example, bus communication needs not to be considered in the beginning, but can be added later on. This step-wise refinedment of platform models helps avoid overengineered test environments.

key technical features

The Chrona Validator is seamlessly integrated with common tools such as MATLAB®/Simulink® and Eclipse. The Chrona Validator supports both open-loop and closed-loop simulations. It works with legacy code, such as C and assembly code, as well as with models and any mix of those.

cutting-edge simulation environment for verification and validation

Software-In-the-Loop (SIL) and Hard-ware-In-the-Loop (HIL) simulation environments represent established methods and tools for testing real-time embedded systems before they are deployed in products. Each of them has key features that are missing in the other. The Chrona Validator is a cutting-edge simulation environment for verification and validation, which uniquely combines SIL and HIL features that are considered crucial for improving the quality of embedded systems.

unprecedented system-level debugging

This benefit results from the ability to pause and step through the simulation of the entire system at different levels of abstraction: Application software can be debugged at the source code level, using all the classical debugging operations for C code. In particular, one can step forward and backwards across preemption points in the controller tasks. Hardware-related behavior can be debugged at the platform model level. For example, the simulation can be paused when the interrupt controller detects an active edge on an input line. Debugging of operating system behavior is done at the level of the operating system model. Plant-related behavior can be debugged by pausing the simulation in MATLAB®/Simulink® when certain plant conditions are satisfied.

system-wide state store/restore

A basic feature is the ability to save the state of the entire computational system (plant model, OS and platform model, application program) and start a simulation from previously saved state.

regression testing

Chrona's Validator offers regression testing at a level of granularity that leads to a solid comparison between several versions of a system, for example, a legacy system and its reengineered or enhanced artefact.

co-simulation

Chrona's Validator has been applied to large industrial legacy systems for simulating the computational part in closed-loop with continuous-time plant models in MATLAB®/Simulink®. For that purpose, the Validator allows co-simulation with other simulation tools based on time synchronization protocols.

fully automated association of execution time information with source code fragments

Chrona's Validator uses instrumentation of the application software with callbacks to the simulator and with functions for calculating execution times of code fragments pertaining to the target platform. Chrona's Validator relies on the availability of execution time analysis for basic blocks of C code. Depending on the target execution platform, this information can be obtained by Chrona's Validator tool suite, or by other commercially available tools. The instrumentation process is fully automated.