Hardware-in-the-Loop: Kernel-Test am echten Gerat - Markus Napierkowski
Categories: Podcasts , Richard Seidl Software Testing
A hardware-in-the-loop (HIL) testing framework automates system software validation on real hardware, integrating with CI/CD pipelines and supporting embedded systems. It offers hardware reservation, infrastructure-as-code configuration, and flexible control via APIs, CLI, and a Web UI, now open-sourced for community collaboration.
Richard Seidl Software Testing
This is the other podcast on Software Testing by Richard Seidl, the episodes are in spoken German but the show notes and site are written in English. Our summaries are generated from AI transcript translations.
- https://www.richard-seidl.com/en/blog/tag/podcast-software-testing
- https://www.richard-seidl.com/en/
Episode Details
- Show Notes: https://www.richard-seidl.com/de/podcast/hardware-in-the-loop-tests
- Published: 2026-10-06T04:00:00Z
- Duration: 00:20:05
- Author: Richard Seidl - Experte fur Software-Entwicklung und Testautomatisierung
Overview
The podcast discusses a long-developed open-source framework designed for Hardware-in-the-Loop (HIL) testing, particularly focused on validating system software such as kernels and firmware on real hardware. The framework enables automated, reliable testing by integrating with CI/CD pipelines and supporting embedded systems like Raspberry Pi. It emphasizes the importance of testing on actual hardware across different platforms and CPU generations to ensure compatibility and performance in real-world conditions.
Key features of the framework include hardware reservation, clean state initialization, and support for complex test scenarios involving multiple interconnected devices. It uses infrastructure-as-code (with Nix/NixOS) to simplify configuration, while a REST API, command-line tools, and a Web UI allow flexible control and monitoring. Developers can reserve machines exclusively, run tests via SSH, and share access for collaborative debugging. The system supports dynamic allocation of resources, VLAN-based network isolation, and automated workflows that reduce manual intervention. Although initially an internal tool, it has been open-sourced to encourage community input and collaboration, particularly in expanding use cases like firmware deployment and broader embedded testing applications.
What If
-
What if you could eliminate hardware bottlenecks in your CI/CD pipeline by treating physical test devices like disposable cloud instances?
- Move: Set up a self-hosted HIL (Hardware-in-the-Loop) testing environment using the open-source framework, starting with Raspberry Pis as test nodes. Use Infrastructure-as-Code (Nix/NixOS) to define and replicate hardware configurations in under 50 lines of code.
- Why Now?: The framework has been open-sourced for two months, is production-tested over 10+ years, and supports REST API and CLI tooling - making integration into existing pipelines feasible without vendor lock-in.
- Expected Upside: Reduce test cycle time from hours to minutes by automating hardware reservation, clean state reset (e.g., USB boot), and test execution - enabling same-day regression testing for firmware or kernel changes.
-
What if you could debug embedded system failures as easily as reviewing a failed unit test in GitLab?
- Move: Integrate the HIL framework’s Web UI and JUnit-XML output into your development workflow. When a test fails, access the shared debugging interface to view serial console logs, HDMI output (via connected Pi), and machine state without physical access.
- Why Now?: The framework already supports automated artifact collection, VLAN isolation, and secure sharing of access secrets - capabilities matured through internal use and now available in the open-source release.
- Expected Upside: Cut mean time to diagnose hardware-related bugs by 70%+ by eliminating manual repro attempts and enabling asynchronous collaboration across time zones.
-
What if you could validate Linux kernel or system software compatibility across 10+ real CPU/hardware configurations before every release - with zero manual setup?
- Move: Define a matrix of target hardware profiles (e.g., x86, ARM, different boot media) in JSON within your test scripts. Use the framework’s API to dynamically reserve and provision each machine with a clean state (e.g., specific USB image), then run compatibility tests in parallel via GitLab-CI.
- Why Now?: The framework already enables dynamic hardware allocation, clean initialization, and CI integration - proven in real-world embedded PC testing - and is now open for customization without licensing barriers.
- Expected Upside: Ship system software with verified multi-platform stability, reducing post-release field failures by proactively catching hardware-specific bugs during development.
Takeaway
- Set up a self-hosted CI pipeline integrated with a hardware reservation system to automate on-device testing for embedded software.
- Use Infrastructure-as-Code (e.g., Nix/NixOS) to define and replicate hardware test environments, minimizing manual configuration when adding new devices.
- Develop test scripts that declare hardware requirements in configuration files (e.g., JSON), enabling automated provisioning without direct API handling.
- Reserve dedicated hardware units (e.g., Raspberry Pi-based test nodes) for exclusive developer access during debugging to prevent conflicts in shared labs.
- Expose hardware control via a REST API and build lightweight command-line tools to enable scripting of device setup, testing, and cleanup workflows.
For a PDF of longer Software Testing Podcast Episode Summaries with Briefing Notes and more detailed summary notes, visit EvilTester Patreon Podcast Summaries.