Supporting UI scalability – from MCU to MPU

We are often asked the question, “what platforms do you support?” or variations on the same that include operating systems, GPUs, rendering technologies, and more. Development teams want to know if Storyboard Suite supports the environments they have, or want to build out.

We always give the same answer: All of them.

Of course, the details are important, so this blog explains exactly what Storyboard Suite supports.

Support across the boards

Storyboard supports a wide range of ARM architectures, from the low-power Cortex-M series used on MCUs to the powerful Cortex-A series used on MPUs. We’ve also supported PowerPC, x86, and SH4 architectures, among others. Storyboard runs on everything from task-based RTOS such as Micrium µC/OS-II and FreeRTOS to full-featured, general purpose RTOS such as Linux, QNX Neutrino, and Green Hills INTEGRITY.

This means you can build user interfaces (UI) for everything from tiny industrial controls to complex automotive instrument panels without having to worry about the particulars of the platform or the effort required to port to different environments when your product line grows.

Here are examples of our demo images running on the STM32F4 (Cortex-M4) and the NXP i.MX 6QuadPlus (Cortex-A9):

STM32F4 (Cortex-M4)

NXP i.MX 6QuadPlus (Cortex-A9)

We support this wide range through extensive development and testing on each platform, ensuring the Storyboard Engine takes advantage of specific board features, such as proprietary graphics libraries, 2D or 3D hardware acceleration, and memory management functions.

The ease at which we provide support for multiple platforms is a result of the way Storyboard is architected: it’s purpose-built for maximum performance and customizability. This flexibility is also exposed to the user, allowing fine control over application configuration and performance:

Application size – The Storyboard Engine is based on a modular plugin system, such that only the required components are included in the system configuration and deployed. Not only does this reduce the application’s footprint, it allows the user to scale functionality down for systems with minimal memory and CPU resources, including:

  • Screen transitions
  • Animations
  • 3D models
  • Input methods
  • Rendering types (polygons, circles, raw canvas, etc.)
  • Lua scripting

Scalability across platforms – Storyboard uses a fixed data model to represent the UI, not generated code, which means the same model can be used across multiple platform-specific runtimes that are tuned for the features and hardware optimizations of the platform. The model itself is event-driven and uses a well-defined API between the UI and the event/messaging system native to the deployment platform, meaning it isn’t tied to a specific environment.

Graphics rendering – Storyboard lets you choose how you want to render graphics, from writing directly into the frame buffer to taking advantage of any 2D or 3D hardware rendering available on the board.

Flexible filesystem – The standard Storyboard deployment uses a filesystem to store the UI data model and associated resources but, if you don’t have a filesystem, you can compile and bind resources directly to Storyboard Engine and flash to the target system.

Font usage – A Storyboard application can either use a font engine to load fonts directly from TrueType or OpenType files, or use pre-rendered glyphs that are stored in ROM.

To try out Storyboard on different platforms for yourself, download and run our ready-to-go demo images.

 

This entry was posted in Partners, Storyboard, UI development by Roy. Bookmark the permalink.

About Roy

Roy figured that the best way to learn something was to try and explain it to someone else. After years of explaining things while standing up, he decided the better approach was to do it while sitting down. Beside a poster of a famous starship. Learning from projects in defense, mobile, and game development, Roy figured out one more thing: real code isn't dead but it could be made better.