Modular vehicle development accross SIL and HIL
Automotive software development and testing is often a complex task. RemotiveTopology simplifies this process by providing a structured way to describe the system (the topology) while allowing seamless integration of virtual and physical nodes. It supports everything from early-stage component development to large-scale Hardware-in-the-Loop (HIL) testing. Making vehicle simulation smooth!
Break silos by decoupling software from hardware
RemotiveTopology was built to break down the barriers between software and hardware development, by virtualizing the entire communication layer. Mix mocks, models, and real ECUs in one setup — so teams can develop, test, and deliver software independently of hardware timelines.
Go from virtual nodes to HIL boxes and advanced simulations. It just works—thanks to containerization and a consistent communication backbone. The video shows a hybrid rig including NI hardware. It's all containerized and based on the same production communication.
Start testing your platform earlier – without the need to wait!
RemotiveTopology makes it possible to test ECUs as well as doing integration testing of core computers – before you have all involved ECUs in place. Don’t sit around waiting for hardware, for access to HIL rigs or for other teams to complete their ECU software. Start testing your software straight away, on your own laptop or in a CI/CD pipeline of your choice.
$ remotive-topology generate -f lighting.instance.yaml build
$ docker compose up -f build/lighting/docker-compose.yaml upCode samples - get stuff done from day 1
Install RemotiveTopology
The easiest way to install and run is to use Docker. We also support Podman as an alternative, simply replace docker with podman in all instructions.
docker pull remotivelabs/remotive-topology:latestStart with low-fidelity mocks
In RemotiveTopology, an ECU can be represented by a mock, a logic-free node designed to send static values across the network. The mock's configuration is managed externally, e.g. through a test case or using a Jupyter notebook.
# 1. Set turnstalk to left as sent from steering ECU on CAN
await self._client.restbus.update_signals(
(
"SCCM-DriverCan0",
[
RestbusSignalConfig.set(name="TurnStalk.TurnSignal", value="LEFT"),
],
)
)
# 2. validate that left turn lights are blinking using front light ECU
sub = await broker_client.subscribe(("FLCM-BodyCan0",
[
"TurnLightControl.LeftTurnLightRequest",
"TurnLightControl.RightTurnLightRequest"
]
))
)
await await_at_most(seconds=2).until(
partial(take_values, sub),
equal_to({
"TurnLightControl.LeftTurnLightRequest": 1,
"TurnLightControl.RightTurnLightRequest": 0
}),
)
Describe the platform
In order to work with RemotiveTopology you need to describe the platform you want to use. The first steps when describing the platform is collecting all the information you already have. This can include signaldatabases such as DBC or complete ARXML files. You can also add missing information using a simple YAML format.
DBC files does not contain that much topological data, but at least you can see what ECUs are available:
$ remotive-topology show topology lighting_and_steering/databases/body_can.dbc
---
channels: {}
ecus:
ADAS: ...
BCM: ...
DIM: ...
FLCM: ...
GWM: ...
RLCM: ...Infrastructure as code
Using RemotiveTopology you describe your virtual test environment as code which ensures consistent and repeatable behavior. The virtual environment can also be combined with real hardware.
1# ECUs to instantiate
2ecus:
3 # a mock for SCCM
4 SCCM:
5 mock: {}
6
7 # a python model for BCM
8 BCM:
9 models:
10 bcm:
11 type: container
12 container:
13 build:
14 dockerfile: ../Dockerfile
15 volumes:
16 - ../ecus/bcm:/app/bcm
17 working_dir: /app
18 command: python -m bcm
19
20 # no behavior needed for FLCM
21 FLCM:
22 channels:
23 BodyCan0:Frequently Asked Questions
RemotiveTopology provides a structured way to describe and run entire vehicle platforms both virtually and connected to hardware. Run the same tests on a developer's laptop or in a CI/CD pipeline. In the initial development phase, you can define your own topology descriptions, gradually incorporating industry-standard specifications. It facilitates early integration testing, allowing engineers to test and iterate without waiting for hardware or final production code. The platform uses containerization and network configuration to closely mimic real networks. RemotiveTopology also enables the use of executable specifications, allowing developers to define functionality in code rather than static documents.
Yes. We offer a free trial licence which lets you try RemotiveTopology for free for one (1) month, just follow the installation instructions.
RemotiveTopology requires an enterprise license and pricing depends on usage. A 'Get-stuff-done package' is offered for a fixed price of 25kEUR, which includes software licenses, customized engineering work, and training. Contact us to get started!
Another option is a free trial licence which lets the user try out RemotiveTopology for free for one (1) month, just follow the installation instructions.
Traditional automotive development often leads to delayed integration tests due to dependencies on hardware availability, which causes errors to surface late in the project. RemotiveTopology addresses this by allowing developers to mock external dependencies and test code in a virtual environment from day one. It enables early interface validation in a simulation closer to the physical implementation. Continuous end to end integration testing reduces late-stage surprises and improves software quality.
"Left-shifting" refers to integrating testing, validation, and simulation processes earlier in the vehicle development cycle. RemotiveTopology supports this by enabling early simulation and validation of system behavior without relying on target hardware. It allows for testing from the initial FIL (Functionality-In-the-Loop) stage to SIL (Software-In-the-Loop), HIL (Hardware-In-the-Loop), and VIL (Vehicle-In-the-Loop).
RemotiveTopology enables teams to collaborate seamlessly from day one, allowing them to iterate and start to validate software immediately, long before hardware is available. The platform's easily shared, runnable nature facilitates collaborative development across different stages and teams by allowing all stakeholders to validate and verify system functionality.
- Integration testing from day one: Enables testing from the start, reducing dependencies on hardware.
- Executable specifications: Allows architects and developers to define functionality in code, forming a testable specification.
- Reduced costs: Minimizes reliance on physical prototypes and reduces expensive late-stage errors.
- Faster time to market: Accelerates development by allowing early validation of software.
- Improved quality: Enhances software quality through continuous integration and validation.
- Flexibility: Allows mixing of mocks, models, virtualized ECUs and hardware ECUs.
- It uses real network protocols, enabling direct connection to physical hardware and usage of standard tools.
- Supports scalability, from Software-in-the-Loop (SIL) to HIL testing
- Open API for flexible customization
- Containerized architecture, enabling interoperability with other simulation tools
The "Get-stuff-done-package" is designed to introduce teams to RemotiveTopology within a structured three-month period. It includes a software license, developer training, and collaboration to create a custom virtual testing environment, and demonstrates how to bridge the virtual system to real hardware and CI pipelines. It focuses on enabling a quick start to integrate RemotiveTopology into the company workflow. The price for the "Get-stuff-done-package" is €25,000
- Tools to deploy and run a topology in a containerized environment
- A framework for writing behavioral models in Python
- A testing framework with network probes and programmable mocks
- Integration with simulation tools such as FMUs and Synopsys Silver
- A file format to define a topology (e.g., specifying ECUs, connections, and behavioral models)
RemotiveTopology uses RemotiveBroker instances as the backbone of the platform. These brokers handle the reading and writing of vehicle data. The software nodes operate within Docker containers, ensuring communication over virtual or physical buses such as CAN, LIN, and Ethernet (including SOME/IP), mimicking real ECU operations. The communication uses actual automotive protocols, making it easy to replace mocks with real components.
RemotiveBroker supports various interfaces including CAN, CAN-FD, UDP (Ethernet PDUs), LIN, FlexRay, and SOME/IP see RemotiveBroker documentation.
RemotiveTopology can be integrated with hardware through partners such as National Instruments (NI). NI provides a hardware platform that can connect to the virtual environment through a gRPC interface. This allows for hybrid test scenarios where virtual ECUs interact with physical sensors, actuators, or ECUs. Read more about the NI integration.
RemotiveTopology supports parsing of signal databases such as DBC, FIBEX, and ARXML, as well as platform or system extract files. RemotiveTopology extracts all necessary information and allows you combine any signal databases your have, see RemotiveTopology documentation.
RemotiveTopology includes a framework to write behavioral models in Python. These models allow developers to define the behavior of the ECU in order to test specific scenarios. RemotiveTopology also supports FMU (Functional Mock-up Unit) to define the behavior of an ECU. See documentation about Behavioral Models.
RemotiveTopology allow developers to used any test framework. RemotiveTopology documentation includes examples for both Pytest and Behave (using Gherkin), see RemotiveTopology Usage.
The RemotiveTopology Framework allows a developer to easily create behavioral models and control their behavior. The framework uses the RemotiveBroker to handle all automotive communication protocols. It includes a restbus which enables continuous sending of messages according to cycle time. Read documentation for RemotiveTopology Framework.
RemotiveTopology integrates with CI/CD pipelines like Jenkins, GitHub Actions, and Zuul. The platform can run tests in these pipelines, and provide reports of the test results through e.g. pytest. By integrating with CI, the same tests used on a developer’s laptop can be used in CI.
Yes, RemotiveTopology integrates with advanced simulation tools such as Synopsys Silver. Synopsys models can mimic hardware behavior with high fidelity and run the actual software intended for ECUs. This allows the inclusion of detailed simulations in a RemotiveTopology setup. RemotiveTopology also supports the use of FMUs (Functional Mock-Up Units) to define the behavior of the ECU.
Developers can interact with a RemotiveTopology setup programmatically through its API, or using tools like Jupyter Notebook, which offers a graphical user interface to interact with virtual ECUs and execute test cases. This user-friendly approach allows the developers to manipulate the state of the system from an UI. RemotiveTopology also supports use of standard tools like Wireshark or candump to inspect network traffic.
RemotiveTopology facilitates a smooth transition between different testing environments, including Software-in-the-Loop (SIL) and Hardware-in-the-Loop (HIL). By allowing for reusable test cases from virtual to physical setups, it ensures that the functionality of the software remains consistent, regardless of whether it is running in a fully virtualized environment, on a simulated platform or on physical hardware. It bridges the gap between these environments by enabling hybrid setups where virtual and real components interact. Standard communication interfaces such as CAN and SOME/IP used from the start also enables this reuse throughout the different phases of development. The tool integrates with NI hardware so a smooth transition is possible.
RemotiveTopology is designed to be open and easily integrated with other tools and environments including CI/CD pipelines, simulation tools, and hardware solutions. It uses standard protocols such as gRPC for communication, thus reducing the lock-in with proprietary systems. It can be integrated into CI systems such as Zuul and Jenkins. It is also integrated with simulation tools such as Synopsys Silver, which is used for high-fidelity modeling. Hardware I/O is integrated with e.g. NI (Emerson) hardware.
RemotiveTopology pricing overview
Here are our different pricing tiers for RemotiveTopology:
Evaluation
If you want to try out RemotiveTopology and #getstuffdone.
for 30 days
Follow install instructions and then getting started. Create your own topology based on your use case and what you want to test.
Single Deployment
Designed for individual use on a single machine
+ €2,500/year for additional users
Run RemotiveTopology on a Linux machine or in a cloud environment in a serial manner (one user at a time) - also connect your HW and enable testing of it.
Cloud Deployment
For teams and organizations,
small and large.
based on your usecase
Use it in your CI/CV pipeline - could be used both in SIL and HIL environments. Enables parallel use by many developers/testers at a large scale.
Want to kick-start your RemotiveTopology experience?
With our Get-stuff-done package, we introduce a collaborative way-of-working; start using RemotiveTopology during a three (3) month period that includes:
- All necessary software licences
- Education and training for your developers
- Services to jointly create a working virtual setup in your environment that demonstrates the key concepts (ECU mocking plus bridging virtual and physical CAN buses) that can be used as a base for further development
- Demonstration how to connect the virtual setup to physical hardware and/or CI pipeline
A typical setup within the three (3) month period:
- Select one (1) ECU to be tested and run this in a virtual environment
- Setup the necessary ECU mocks (typically 5-10 ECUs) communicating over actual automotive protocols (CAN, SOME/IP etc)
- Create a number of test cases to verify the ECU under test
- Create a Jupyter Notebook, which enables interaction with the ECUs using a graphical user interface
- Run on a Docker enabled Linux PC or cloud environment
Get-stuff-done package
A collaborative way-of-working
3 months unlimited usage
Articles related to RemotiveTopology
Join the automotive rebels that #getstuffdone with RemotiveLabs!
