All of multiSIM’s solutions are build on the D-SIM Framework. The framework was developed with both end users and developers in mind and provides a unique combination of both ease-of-use and simulation fidelity. To make true rapid development possible the D-SIM library provides an all access high performance interface to any variable in a simulation.
The powerfull web interface makes it possible to easily debug and test simulations. The distributed design provides the ability for developers to connect their development environment to an actual simulator and develop or debug with the actual simulator hardware.
In the D-SIM Framework custom software and hardware can be integrated with minimal effort.
Open Simulation is our philosophy that potentially every variable in a simulation should be accessible. Every computer in the simulation network that runs a D-SIM node has access to these variables. Customers can interface with these nodes and do anything they like with a variable, such as:
- script, log and analyse (for experiments)
- re-use in own software
- interface to hardware
- build new simulation assets
In the D-SIM Framework any simulator can be integrated. Both the simulator hardware and the software can be coupled to the framework by installing nodes on the corresponding PC’s and by adding relevant variables to the Open Simulation process. At multiSIM distributed simulation is standard, not optionally!
Integrate your software
The same interface that multiSIM uses for building simulations and integrating software is available to all customers.
The D-SIM shared library provides easy access at a very high performance (typical <50ns reads and <100ns writes) and is thread safe. D-SIM supports both 32-bit and 64-bit Windows and Linux.
While any application capable of interacting with a shared library can be integrated, multiSIM provides the following actively maintained integrations:
- C++ (MinGW/GCC and Microsoft Visual Studio C++)
- Matlab Simulink
- REST API
Accessing variables through these integrations is as simple as:
#include "DSim/Variable.h" DSim::Entity f35("f35_1"); DSim::Variable::T<double> f35_altitude(f35, "reference_frame/inertial/position/altitude"); f35_altitude.write(1234.); // Writing to a D-SIM variable double altitude = f35_altitude.read(); // Reading a D-SIM Variable
f35 = DSim.Entity("f35_1") f35_altitude = DSim.Variable.Double(DSim.Node(f35, "reference_frame/inertial/position/altitude")) f35_altitude.write(1234) # Writing to a D-SIM variable print(f35_altitude.read()) # Reading a D-SIM Variable
Integrate your hardware
Each type of hardware often has its own custom communication protocol. By writing a simple wrapper through use of the D-SIM software interface is it easy to connect new hardware, when an existing D-SIM integration is not available.
Through using D-SIM as the connection fabric between the different hardware and software components a large number of components can be managed. Since D-SIM provides a distributed structure the hardware can be connected to any computer in the simulation and the web interface makes it easy to troubleshoot a system when hardware issues occur.
Some examples of hardware that we or customers have integrated are:
- Cockpit Hardware (e.g. buttons, switches)
- Control Loading
- Medical Devices (e.g. pulse oximeter)
- Motion Platforms
- Video Projectors/Monitors (for power control)
The D-SIM Operator Interface is map based and runs in a browser application. On the map all the different simulators (and their data) can be accessed and operated. Our interface runs in a webUI and can be opened on any PC that runs a D-SIM node.
In the interface all the simulator processes and variables can be monitored, and new processes can be added easily. For each simulation or network of simulators, the Operator Interface provides the tools to create complex training or research scenario’s and to interact with them through easy (customized) menu’s and interfaces.
Since D-SIM is based on Open Simulation and almost all variables are accessible, the customer can easily adjust the operator interface or even develop their own (e.g. in HTML5).
- Distributed by default
- Access to any variable
- Designed for rapid development
- Designed for integrating custom software
- Designed for integrating custom hardware
- Windows and Linux support