Experienced managers of embedded systems programs understand that the most difficult aspect of embedded systems project planning is the logistics unique to embedded systems. An embedded systems design project involves a myriad of project schedule and logistical dependencies, and the complexities associated with managing these dependencies can have dramatic effects on product development costs and the return on investment of embedded design activities.
Typically in an embedded systems project, a hardware team is responsible for designing the custom hardware for the application, and the firmware team is responsible for designing the firmware, which runs on the hardware. This tight coupling creates a large potential for unexpected increase in design costs, as firmware teams are forced to wait while the hardware design is finished or debugged. Firmware application development can also be halted due to other logistical issues, such as unavailable third-party hardware components. Another very common source of dramatically increased development expenditure is the logistical complexity of implementing and testing the business logic of a firmware application. For example, business logic may involve interaction with large equipment or remote areas such as oil rigs, which are not amenable to sitting neatly on a firmware developer’s desk.
Another common logistical issue associated with embedded firmware development is associated with interaction complexity. For example, firmware running on an engine control unit (ECU), which is responsible for monitoring sensors and devices in a vehicle, has an extremely large number of use cases and scenarios. The requirement of having to physically connect an embedded system to an engine and develop a firmware application that interacts with the engine is an arduous logistical challenge to say the least. Particularly when the system must be manually manipulated to create the interaction conditions necessary to test the firmware application development.
The Virtuoso virtual device paradigm simplifies this design methodology considerably in many respects. Virtuoso provides a platform for a virtual device to be easily created, in conjunction with the virtualization of any peripheral system components needed to facilitate the implementation and testing of the business logic. Since the virtual device is already hosted in a PC application and running a high-level language environment such as C#, peripheral systems could then be easily simulated in the same high-level language environment to interact with the virtual device. The firmware application developer could then focus on the problem domain in the most natural and direct way. For example, to test a firmware application’s response to a 10,000 PSI condition in an oil rig application, the developer need not spend the time driving to a rig and testing with a physical system that generates the conditions necessary to test the business logic, instead the condition can be virtualized with a simple slider control which hooks in at the appropriate driver level, to provide the input needed. When the developer runs the virtual device and controls the slider representing system pressure, as far as the firmware application knows, it is running in embedded electronics installed on an oil rig and watching the pressure increase or decrease. The value of decoupling the business logic from hardware setups would be difficult to overestimate, as any firmware developer who has frustratingly lost days of productivity due to a bad cable or faulty or difficult-to-work-with setup would attest to. Once the firmware application has been developed and tested, now in parallel with the hardware development and the rest of the project activities, when the hardware is complete the virtual device is simply ported over to the hardware target, and the product is ready to ship, as the flow diagram below illustrates.