Renode

Renode lets you assemble virtual System-on-Chips from building blocks, including Cortex-M, Cortex-A, RISC-V and other CPUs as well as a variety of communication buses and interfaces.

It's all a matter of simple, text-based configuration, so that you don't have to copy-paste code and modify hard-coded values to build the platform you need. The flexibility or Renode enables e.g. pre-silicon development of hardware-software systems - see the CoreGuard customer case for an example.

Add LEDs, buttons, sensors, snap on a radio module and you're done! Yes, Renode can also simulate entire devices which means you can run unmodified firmware that you are/will be using in production.

Your virtual boards can include multiple SoCs, sensors and actuators. This lets you transfer to a software-first workflow: write your software using Renode, play around with various hardware configurations and build your physical platform based on real needs.

This is where things get even more interesting: connect several virtual boards in one Renode simulation environment using wired or wireless interfaces and test your protocols, system-level security, usage scenarios.

Thanks to a unified, deterministic time flow, you can stop and debug the entire system state at the same time, save its state and share with your colleagues in a collaborative environment, and set up Continuous Integration to repeatedly test multi-node setups without the need for creating costly physical testing rigs - and with the freedom to copy, distribute, scale as needed - Renode is all software!

Thoroughly testing an IoT setup is very difficult, especially at scale. Debugging of one node affects timing constraints in communication with other nodes. Bugs in corner cases are usually detected too late.

Debug the whole system at once, attaching GDB to any node and seeing the synchronized state of the entire network.
Create breakpoints and watchpoints that don’t alter your software’s behavior.
Use Continuous Integration (CI) to automatically test each iteration of your software.
Simulate different conditions, configuring e.g. the network medium to your needs.

Development is often delayed by lack of hardware. Iteration cycles are slow because deployment and testing are error-prone, time consuming and frustrating. Debugging on real hardware is difficult.

Using emulation, start developing software before hardware is ready.
Parallelize development even if you do not have enough boards, work from anywhere.
Adjust the emulated platform to your needs, experiment, give feedback to the hardware team.
Debug and test with better tools, more control and fewer problems.

Reproducible testing in IoT is virtually unattainable: bug hunting efforts are difficult to distribute among developers, and onboarding new team members is hard.

Save the state of emulation, send it to another developer for analysis.
Record events occurring in a complex setup, replay them for an isolated machine for simpler and faster debugging.
Easily analyze the state of every peripheral of every node of the system.
Strictly control virtual time, preserving deterministic execution regardless of the host machine.

Security in IoT is often neglected which can have severe consequences, but it's impractical to verify behavior in different conditions.

Use standard PC-based tools to test different attack vectors.
Configure sensor input, node positions and other environment parameters.
Analyze network traffic, inject errors and observe results.

Working with heterogeneous systems requires lots of different hardware. Backward compatibility requirements increase the cost and complexity of testing.