Virtuoso is the flagship workflow product in Embeddetech’s embedded systems tool suite. Virtuoso is simply put the state of the art in embedded firmware development workflows. No firmware project is too small or too large for Virtuoso hardware virtualization. Free your embedded application design from its natural hardware constraints with Virtuoso.

Core Framework Features

The Core Framework currently comes out of the box with a C#/WPF .NET host plugin available for use under the terms of the Core Framework EULA. This means you can create a C#/WPF host, drag and drop components, configure them and wire them up with each other for interaction, and the host plugin will translate your schematic design to a fully fledged C# application written with a Model-View-ViewModel design pattern. The output host emitted by the schematic editor can then be extended directly in C# and XAML, while still being able to modify at the schematic level.

The Core Framework is architected to support host plugins that allow schematic designs to be exported to any “host”. The “host” can be anything and is just an abstract concept of anything that meaningfully hosts multiple interconnected and configurable components and must be built. You can write a custom host plugin to streamline any operation that involves graphical design and export the graphical design in any way imaginable.

Anyone can write and share a host plugin to adapt it to any host language or adapt it to a completely proprietary output. The Core Framework can thus be used as a completely proprietary internal workflow improvement and automation tool.

When a host component on a schematic is itself a host of internal components, interoperability of different technologies is possible. Adding an Unreal Engine scene as a component of a C# host is an excellent example. With a C# host component container, actors in a photorealistic 3D scene can be interacted with as C# classes in the same exact way as any other host component. With sub-hosting, seamless interoperability of complex hierarchical systems and technologies becomes possible.

Because all Virtuoso packages are available on the Montage Marketplace, whether free or premium, the packages get visibility to other Virtuoso users. Using Montage, you can easily publish and license packages to generate revenue or find quality other components that others created. Montage handles the licensing complexities, so you can focus on developing.

Not only is the host platform extensible as a plugin, but components and port types are also completely extensible. You can use the framework conventions to write new components, define new port types, and completely redefine or extend the translation of port connections. You can easily create a new port type for C# hosts and define what it means for that port type to be connected to any other port type. You can easily create new components that then use any port types in the Virtuoso ecosystem.

The core framework itself consists entirely of Montage Packages available on the public Montage package feed, and all extensions, including host plugins, component metadata, port metadata, and host components, are also available on the feed. New functionality provided by the community will be continually available, and you can also easily create and publish your own extensions of Virtuoso packages which integrate directly into the framework and are accessible on the Marketplace.

Nuget is a homogeneous package management system, meaning all Nuget packages are designed to be installed to .NET project types (a single “Installation Target” type, in the Montage vernacular). Montage is a heterogeneous dependency management system, meaning anything can be defined as a package and referenced as a package dependency, including software installations. When Montage Activities are installed, everything needed for that Activity to work is installed, guaranteeing portability of the Activity. When you are sharing an Activity on Montage you can specify not only what needs to be inside a project, but also what needs to be installed on the computer or copied to the file system to ensure your Activity will be useable. This removes frustration and setup time on the user’s part and is a great way to manage build archives. Composite example projects containing references to packages from many merchants can be shared, and the Activity user can effortlessly pay all licensing fees to all merchants in a single step. Montage Activity Sharing takes collaboration to the next level.

Embedded Development Toolkit Features

Virtuoso allows powerful virtual device applications to be created using Microsoft’s Visual Studio IDE. Virtuoso works with Visual Studio 2013 and Visual Studio 2015, as well as Microsoft’s Blend for Visual Studio. The Virtuoso Visual Studio integration creates a seamless and powerful embedded virtual device development platform.

Functions in the target C project can be specified as interrupts and are then exposed as interrupt ports in the schematic editor. Any event source from any component can be effortlessly wired up to trigger the interrupt. Drag and drop a timer onto your schematic and specify the tick frequency in microseconds, wire it up to your timer tick ISR, and you have a clock source.

When you’re developing your virtual device there is no hardware, there is no in-circuit debugger, and there is no download time. There are no fragile cables strewn across your desk. There is only you, your application code, and the debug button in Visual Studio.

Embeddetech’s Montage Solution Management Software integrates seamlessly with Virtuoso. Keep your Virtuoso Visual Studio project and your embedded target project perfectly in sync. Create and manage other variants of your solution as well, including the processor-specific embedded target build, the Virtuoso virtual device build, or an alternate target platform on a different processor. Solution management and hardware migration the way it was meant to be.

Events can be configured to source events from the embedded C code to the rest of the host. The events are exposed as ports on the target’s schematic editor component, and as events on the C# target model class. You can respond to events from the target either by writing a C# handler or by wiring it up to another component in the schematic editor.

When you compile a Virtuoso C project, any statically linked (non-stack/non-allocated) variable can be easily exposed as a C# property on the target model class, which also shows up as a port on the target component in the schematic editor. When the variable changes in your C application, it updates automatically in C#. Or if the variable changes in C#, the variable synchronizes in your C application, immediately and automatically. You can interface to the variable either in C# using the target model class, or in the schematic editor by wiring up the variable port to another component. Tooling up for virtualization or custom firmware analytics has never been easier.

A virtual embedded program, like a real embedded system, needs to power down and restart. And a virtual embedded program, like a real embedded system, needs to be able to store non-volatile persistent data. In Virtuoso, any statically linked variable or buffer that is managed by Virtuoso can be specified as volatile or non-volatile.

Does your virtual device’s virtual NAND flash driver need 32MB of persistent memory? No problem. Simply create a 32MB byte array in your virtual NAND flash driver, and tell Virtuoso it needs to be non-volatile. When your virtual device powers down, it will be saved to disk. When your virtual device powers up, we’ll load it from disk and it will be waiting for you before you’re even executing the first line of code.

Virtuoso comes out of the box with a rich library of content to get your project virtualization started. Whether you need a provider or consumer of digital, analog, general purpose buffer, or stream-based data, chances are there is a high-quality component waiting for you.

  • Photorealistic user interface components including LEDs, push-buttons, gauges, sliders, and more
  • Universal touch screens with user-defined display resolution and display encoding
  • A host of non-visual components, such as data stream adapters for serial port communications, TCP/IP communications, virtual stream communications with other virtual devices, and much more

New components can be continually made available by Virtuoso or other merchants on the Montage Marketplace.

Unreal Engine is the engine and workflow of choice for modern high-end gaming and 3D visualization. Verismo is an adapter framework to allow an Unreal Engine game to be seamlessly integrated into a .NET application. With Verismo you can interface with any Unreal Engine game actor as a .NET class and hook that up to your virtual device. Using Verismo and Virtuoso together, you can create nearly photo-realistic, real-time three-dimensional scenes with your fully interactive product executing actual embedded code during the development process. Welcome to the future of embedded product development.

Whether your embedded data flow consists of UART/serial data, CAN traffic, A/D sampling, or wireless or TCP packets, getting data into and out of your application is a breeze with Virtuoso targets. These data streams are exposed as Stream ports on the C# class and schematic editor component, so you can easily source or consume data either programmatically in C# or by connecting the streams to other components in the schematic editor.

Your optimum workflow could mean interfacing your virtual device’s data to the “real world” exactly like your target, for example by connecting a wireless module eval board to the virtual device’s computer and using it to communicate with your system or using your PC’s ethernet to open a TCP socket for your virtual device. Or it could mean creating a powerful test harness workflow, by for example streaming recorded audio or analog data into your virtual A/D input stream. With Virtuoso, you have complete control of your data management and flow, regardless of the type of data.

When your embedded hardware involves specific chipsets that are interfaced to by your target application, proxy devices allow those real-world chipsets to be interfaced to directly. The proxy component looks and feels like any normal host component, with variable, stream, event, and interrupt ports that can be connected to. But the proxy components relay those interactions directly to the physical hardware, typically over USB, allowing composition of virtual hardware platforms that use the real hardware for development.

Creating a virtual device in Virtuoso is as simple as creating a function in C. Configure it as a Virtuoso thread, and you are up and running. If you power down your virtual device (while the virtual device simulation host itself is still running), the thread will stop, just like in real life. If you power your virtual device up again, your non-volatile variables and initialized volatile variables will be ready and waiting for you at the start of your thread.

Virtuoso is architected using a Model-View-ViewModel design pattern, starting with a C# model class that encapsulates your virtual device. This facilitates rapid and loosely-coupled development of a virtual device using all of the power of .NET and WPF. Slap together a quick functional virtual device, then go back and re-skin it later.

For the perfectionist at heart, with Virtuoso you can design your own application-specific photo-realistic virtual device as your development platform. Render your product using your CAD software and bring it to life as an interactive virtual product. Use out of the box Virtuoso components or standard WPF controls to make your rendering come alive, under direct control of your actual embedded firmware application. Bring product definition, conceptualization, and marketing coordination to a whole new level.