Platform-based embedded software design offers a structured way to develop control systems that must meet functional requirements while operating within strict hardware and real-time constraints. Unlike conventional desktop software, embedded control software must produce the right result at the right time, often with limited memory, processing capacity, and energy. Development methods therefore need to address hardware choices, software architecture, testing, and project management together.
An agile toolkit for this work combines iterative planning and delivery with practices designed for hardware-bound systems. Its central ideas are to build on a configurable platform, partition functionality between hardware and software, and make verification—including timing checks—a continuous part of development.
Why embedded control requires a different approach
A typical control application acquires input data, applies a control algorithm, and produces an output. The system’s correctness depends both on the output and on when it is delivered. A late control signal may be as consequential as an incorrect one, so testing only the logic on a desktop environment is not enough.
Embedded teams must also account for constraints such as execution time, code and data memory, and energy consumption. Implementation errors involving finite-state machines, memory use, or timing can undermine system behavior. Where a failure could put people or equipment at risk, development practices must address safety and reliability from the outset rather than treating them as final-stage checks.
Agile practices can help teams respond to changing requirements and surface risks early, but they need to be adapted. Iteration should not mean postponing architecture or non-functional requirements. Hardware and software decisions, verification, and project controls all need to be part of the development lifecycle.
Platform-based embedded software design
The platform-based approach starts with a library of architecture and software components. A system designer selects a platform instance for the intended product, then configures or customizes it to meet the application’s requirements. The software layer, including an application programming interface (API), provides a consistent way for application code to use platform capabilities.
This approach supports reuse while leaving room to adapt the platform. Designers can assess whether components are needed and refine the configuration as the product requirements become clearer. The aim is to balance performance and functionality against development time and cost—not to assume that one platform configuration fits every product.
Partition functions against system constraints
Product functionality can be assigned to hardware or software elements. The partitioning decision should consider the application’s execution-time, energy, and memory requirements. Teams can make these decisions iteratively: implement and evaluate a portion of the system, then refine the allocation as they learn more about the constraints.
This also creates a path for software-driven hardware decisions. Early builds and performance analysis can help determine which platform components are necessary. In the reported soft-starter prototype, the final hardware configuration no longer required several converter channels and external RAM used in the initial development platform. This illustrates how evaluating the product against its actual requirements can inform hardware configuration; it is not a general guarantee that every project will reduce its hardware.
Build testing around correctness and timing
A key practice is to create unit and functional tests before implementing each application function. Tests help exercise code paths and clarify expected behavior, while modular code makes individual functions easier to verify and change. The method also proposes translating application code into a formal model so engineers can check specified safety properties using model checking. If a property is not satisfied, a counterexample can be added to the test suite and used to guide a correction.
Testing should reflect the distinction between hardware-independent and hardware-dependent software:
- On a PC: Run hardware-independent code through unit tests to exercise logic and code paths without simultaneously debugging the target hardware.
- On the target: Test hardware-dependent behavior and verify that the application meets its timing requirements in the operational platform context.
- Across changes: Use automated builds and regression tests to identify compilation failures and unintended behavior as code is integrated.
Performance, energy use, program size, and data memory should be monitored against the application’s limits. Profiling and target-platform analysis can help identify where further optimization is needed. The development sequence matters: establish working functionality, then assess and optimize the system as a whole rather than tuning isolated code prematurely.
Use agile planning without losing engineering control
The methodology organizes work across exploration, planning, development, release, and maintenance. In exploration, stakeholders and engineers identify initial requirements, constraints, and a suitable platform. Planning turns prioritized requirements into sprint goals and smaller tasks. Development delivers increments, with regular team coordination, testing, and optimization. Release and maintenance address deployment, issues, and subsequent changes.
Clear responsibilities support this process. A platform owner sets product targets and priorities; a product leader coordinates implementation and integration; feature leaders can coordinate work across subsystems or teams; and the development team builds and tests the system. Backlogs, issue tracking, version control, and continuous integration help keep work visible and changes manageable.
These practices are especially useful when requirements evolve or technical risks are not fully understood at project start. Short iterations and customer reviews provide opportunities to validate assumptions, while prioritization can bring high-value or high-risk functionality forward. Non-functional requirements still need explicit attention, even when functional features are the focus of early increments.
What prototype results suggest
The approach was applied to a digital soft-starter and an induction motor simulator using embedded platforms with constrained resources. The reported work combined unit and functional testing, target execution, iterative development, and platform configuration. The authors reported average cyclomatic complexity values of 1.43 and 1.61 for the two prototypes, respectively, and described improved modularity through testing and refactoring.
These results illustrate how the practices were applied, rather than establishing a universal productivity benchmark. The projects involved small teams and specific equipment, and the work notes that comparing agile and traditional methods requires further study. Engineering teams should therefore treat the approach as a set of practices to adapt and evaluate against their own product, safety, and delivery needs.
Conclusion
Embedded control development is a coordinated hardware, software, and verification challenge. A platform-based, iterative process gives teams a way to manage that complexity: select and refine reusable components, allocate functions with system constraints in view, test both behavior and timing, and integrate changes continuously. For engineers and decision-makers, the practical lesson is to make resource limits and verification part of everyday development—not issues to address only after the software is complete.