Creating Custom UI for Automating Manual Testing of Embedded Systems

Manual testing devices in development and QA phases is rarely smooth. Testers often need to physically disassemble the device, connect lab power supplies, and manually trigger test conditions, simulating real-world scenarios over multi-day test cycles.

This approach has several downsides:

• It’s slow and inefficient. Connecting wires, configuring sensor simulators, and pushing buttons takes time and breaks focus.
• It causes physical wear. Repeated handling can lead to mechanical wear or damage over time, and testers must continuously repeat the same manual steps.
• It limits test coverage. Long-term conditions like gradual battery depletion are difficult to reproduce consistently.
• It drains resources e.g., real batteries get exhausted during testing and require frequent replacement.

 
We ran into all of this while developing an IoT battery-powered device with shut off water valve and flow sensor. It was clear that we needed a smarter approach – one that would let us automate real-world scenarios and track firmware behavior in detail.

So, we built a test platform with a UI that simulates power states, sensor inputs, and valve behavior, and that could be used by both QA engineers and firmware developers.

The Problem: Manual Testing

Our client’s device required rigorous testing under a wide range of real-world scenarios. However, the testing workflow was entirely manual, so we needed a faster, smarter, and more repeatable way to simulate device behavior.

The goal was clear – building a UI-based solution that could:

• Simulate device behavior in various operating states
• Replace physical test setups with virtual simulations
• Allow configuration of device ports and sensors
• Provide real-time feedback and logs
• Enable simulation of failure conditions

The Solution: A Modular Simulation Platform with Custom UI

To meet that goal, we developed a custom desktop-based UI platform that acts as a simulation and test environment. It connects to the device via USB and enables firmware engineers and QA teams to simulate a wide range of real-world operating conditions with a few clicks.

During testing, the device is used exactly as it would be in real-world conditions. The test platform lets users configure the simulated water flow sensor type, the simulated valve type, and the battery state – all through the UI.

Core Functionalities

Simulated Power Supplies

• Emulates battery states: Fully Charged, Low, and Empty, without using physical batteries.
• Transitions between states are triggered manually or automatically using Python script.

Valve and Flow Sensor Simulation

• Simulates different types of flow sensors and adjustable flow rates.
• Emulates valve operations, including calibration, warnings, and failure scenarios (e.g., incorrect sensor connection, stuck valve, etc.).

Full Visibility into Device Behavior

• Displays real-time data: current consumption, and full firmware logs.
• Log filtering tools for both QA and development teams.

Built-in Automation Support

• REST API-based automation scripts control state transitions (e.g., simulate 3-day battery discharge cycle).
• Enables consistent, repeatable testing.

Modular and Scalable Architecture

• New tests and device types can be integrated with minimal effort.
• Layout and modules can be customized per device variant or future project.

The Solution: How It Works: Test Workflow Simulation

In real-world use, our device under test is expected to detect low battery levels, respond accordingly, and notify users via web and mobile apps.Validating this behavior with custom UI means that the test platform can simulate these scenarios with a single click, enabling engineers to test and repeat battery-related edge cases with less effort, more safety, and consistency.

The process is simple: The STB (simulation and test board) is connected via USB, and the desktop application is launched. Once the connection is established, power (battery) can be turned on, and live firmware logs are streamed directly into the platform, offering immediate visibility into device behavior.

Example: Battery testing scenario

Day 1: Full battery state

Day 2: Low battery state

Day 3: Empty battery state

Throughout this process, the UI monitors how the device responds:

• Can the device still be used at low battery state?
• Does it send the correct push/email notifications when the battery is low or empty?
• Does the product detail page visually reflect the battery state change (e.g., blue = OK, yellow = warning, red = critical)?

Instead of waiting for physical battery drain, the tester changes states with a click – saving hours of manual work.

UI and HIL Testing

This UI became an essential part of our client’s Hardware-in-the-Loop (HIL) testing environment. It allowed the simulation of:

• Different power sources (USB, battery)
• Valve failure and leakage events (e.g., water leakage simulation)
• CO₂ tank pressure changes
• Flow rates and sensor types

With complete control over the simulation parameters and detailed logs, developers and QA engineers were able to precisely replicate real-world failures, test system resilience, and debug firmware behavior faster.

Results

The impact of this UI is immediate and measurable:

• Faster Testing Cycles: A process that used to take days with manual setups was reduced to minutes or hours.
• Reduced QA Engineer Stress: No need to physically interact with the device for each test cycle.
• Improved Product Quality: Broader and deeper test coverage with consistent results.
• Accelerated Time to Market: Developers and QA teams could run more tests in parallel and identify issues earlier.
• Standardized Testing Process: Automation and modularity enabled repeatability across teams and devices.

Why It Matters?

For engineering and R&D leaders, solutions like this go beyond short-term efficiency. They’re enablers of long-term product quality, process stability, and development scalability.

• By simulating complex real-world conditions early in the cycle, your teams can find issues before they become critical.
• It reduces reliance on physical hardware, lab setups, and manual workflows—freeing up engineering time for actual innovation.

And with modular architecture, it’s designed to grow with your product – supporting maintainability and future test scenarios without starting from scratch.

At ARS Embedded Systems, this is how we think about embedded development: not just code and circuits, but the entire lifecycle – from concept to validation. And this project showcases how user interface design, when built with embedded expertise, becomes a driver of product excellence.

Let’s Talk

If you’re facing similar challenges in testing, simulation, or validation, reach out – we’d be happy to explore how we can help streamline your development pipeline.