Emulators are in principle simple systems, but achieving high performance is often contrary to other software development goals such as maintainability and portability. In addition, the introduction of space qualified, multi-core high performance processors had a significant impact on the design and implementation of the emulators, that for example may be used in Software Validation Facilities (SVFs) and operational simulators.
Terma Emulator (TEMU) provides instruction-level simulation of spacecraft processors, executing the emulated target's instruction set in a virtual machine running on host systems. Engineers can run their actual flight code and catch critical issues before the satellite will be on orbit.
This capability becomes essential when you consider that space-qualified hardware boards often cost 20,000 euros or more, sometimes well above 100,000 euros. Having access to a simulation environment early in development can make the difference between project success and costly delays.
Running unit tests on emulators instead of different architectures ensures software handles low-level issues such as endianness correctly. The system provides stress testing for target compilers early in development, catching compiler bugs before they impact flight software development during later phases when the impact is greater.
The risk of bugs in target system compilers should not be understated. TEMU catches these issues early by running unit tests on the actual target architecture rather than a completely different system.
In addition to ensuring representative endianness and the use of the target system compiler, emulators provide additional benefits for software development. These include fully deterministic execution, ability to snapshot simulation state and for some emulators the ability to run code backwards. One of the more important aspects is, however, the ability to use the emulator command line interface for running fully automated tests. TEMU for example allows for the execution both its own interactive scripting language TScript, and Python scripts. These scripts can for example intercept and analyze emulated bus traffic (e.g. serial port traffic), greatly simplifying unit testing.
Emulator accuracy often exceeds hand-made performance estimates. TEMU enables routine and automatic performance analysis execution before physical hardware becomes available. Bus traffic budgets can typically be verified accurately, through detailed simulation of peripheral interactions.
A virtual 1553 bus implementation can for example provide runtime warnings when onboard software exceeds predefined thresholds. Engineers also receive quantifiable performance metrics for the emulator itself, some of it which directly reflect the flight software behavior. These metrics includes simulated instructions per second, speedup / slowdown numbers, CPU utilization for the target application, number of MMU flushes per second, number of cache flushes per second, and many more.
Software Validation Facilities (SVFs) are full system simulators designed to execute complex system tests. Often, TEMU serves as the processor core within an SVF architecture, validating that final onboard software operates within budget constraints and interacts correctly with simulated environments. It is also possible to build an SVF using TEMU as the main simulation engine.
SVF testing involves up-linking of telecommands and inspecting telemetry responses. Since SVFs use virtual time when hardware is not in the loop, simulation accuracy becomes more critical than real-time performance. TEMU provides the precision required for system-level validation.
In SVF, TEMU not just tests individual functions. It validates that the complete software system interacts correctly with its environment, from sensor inputs to communication protocols.
Operational simulators integrate into ground infrastructure where mission control systems serve as the primary user interface. These simulators support operator training and testing of onboard control procedures using real flight software without risking spacecraft or requiring spare hardware.
Running actual flight software means most bugs in flight software are also simulated. When testing operational procedures, validation occurs against real software implementation rather than specifications alone. This approach provides authentic testing environments for mission-critical procedures.
The flexibility proves valuable for constellation projects where multiple spacecraft must coordinate operations. Engineers can validate complex multi-spacecraft procedures in simulation before attempting them with actual hardware. For operational simulators, real-time performance tends to be more important; and TEMU offers advanced features such as code-substitution, programmable idle mode and others, that allow a simulator developer to optimize the performance for the operational use case.
Physical hardware procurement and setup costs can delay validation activities by months. TEMU eliminates these barriers by providing immediate access to emulated hardware environments. Teams can validate multiple software versions simultaneously without additional hardware investments. Emulators are also enablers for effective CI/CD approaches when developing on-board software.
The emulation approach reduces total cost of ownership for validation infrastructure. Development cycles accelerate while maintaining validation rigor required for space applications. This economic advantage becomes particularly important for New Space companies operating under commercial cost constraints.
Engineers catch issues early, validate faster, and reduce project timelines. The system enables validation activities to begin immediately upon software completion rather than waiting for hardware availability.
Future missions require software that adapts in real-time to changing conditions, coordinates autonomously with other spacecraft, and operates reliably for decades without human intervention. TEMU provides the validation foundation that makes these capabilities achievable.
TEMU enables Earth-based validation that matches space-qualified performance requirements. Engineering teams can deploy software knowing it has been tested under conditions that match space operational realities without leaving the development lab.