The Virtuoso Embedded Target Development Toolkit allows embedded application C/C++ code to be cross-compiled, developed, run, and tested in a virtual device in parallel with the target hardware. Some of the many possible reasons for virtualizing the hardware for an embedded application are as follows:
- The custom target hardware isn’t available yet, and you want to be able to develop and test firmware application code in parallel with the hardware design.
- You want to develop and test your firmware application code in parallel with the hardware design to accelerate time to market.
- You want unlimited software breakpoints and a significantly more responsive and powerful debugging experience, compared to in-circuit debugging.
- The target hardware is expensive, and the cost of providing all firmware developers and test engineers with a hardware setup each time the hardware is revised is substantial.
- You don’t want the project dependency of having to provide development hardware to firmware developers, which can force poor project management decision-making, rush the hardware design, and cause expensive expedite fees.
- You are just starting out learning embedded programming and don’t want to spend money on target hardware.
- You want a single platform with a limitless opportunity for example projects to rapidly increase your embedded firmware development skill-set at the click of a download button.
- You want to drastically improve your debug efficiency by stepping through code locally versus stepping through code on a remote target.
- You want to improve the testability of your embedded application using powerful custom test harnesses.
- You are dissatisfied with the toolset or IDE for your native target, and you want to leverage the power of Visual Studio for the application development and debugging.
- You want to interact with a photorealistic virtual device at the proof of concept stage to improve and streamline the product definition process.
- You want to learn how to develop embedded applications, but you don’t want the headache of learning the target-specific tools, debugging processes, IDEs, etc. You just want to download an example and get started with no setup time.
- You want more control over the data flow or I/O interfacing to the embedded hardware for sensor research and other applications.
- You want more control over your development capital expenditure by having the option to demonstrate functionality to your stakeholders without needing to make custom hardware design expenditures.
- You want more control over your deliverable schedule to quickly demonstrate functionality to encourage management assurance and trust.
- You want an easier way for embedded firmware developers to collaborate at different remote locations without the logistical challenges of custom embedded hardware setups.
- Your normal development workflow involves substantial logistical inefficiencies, such as extended off-site travel or interfacing to non-portable equipment.
- Your application involves multiple targets/microcontrollers/threads, and you want to debug multiple targets simultaneously at the system level.
Regardless of the specific reason, all embedded systems firmware development tends to share the same thing in common: embedded C or C++ code must be developed to execute on an embedded microprocessor, and this microprocessor interfaces somehow with the external world. Whether that involves an LCD and a keypad, or an analog input, power relays, a communication bus, or any other peripheral, most of these interactions with the outside world can be logically abstracted fairly easily to allow the application level code to be tested.
Virtuoso is a framework built to significantly reduce the cost barrier for virtualizing common or custom embedded hardware components, allowing developers to thoughtfully design the development workflow itself for maximum productivity.