To improve the accessibility of our content, please find the audio version of this blog post.
Can a team working with various microcontrollers (MCU) and microprocessors (MPU) find a way to save resources and optimize workflows? One answer to this question comes from Crank Software, a member of the ST Partner Program. The globally-focused Canadian-headquarted company is famous, in part, for Storyboard, a cross-platform framework for embedded GUI developments. As the video below shows, the tool enables the creation of sophisticated and engaging interfaces. Developers can even try demo images for STM32 MCUs and our MPU to start testing the environment in just minutes. The demo images are also a great example of the framework’s ability to bring a similar UI to a wide range of components. The images, therefore, serve as an object lesson to engineers looking to migrate from an MCU to an MPU, or vice versa.
The Challenges of Migration
Working with a wide range of components has many advantages. For instance, it can help a company enjoy greater flexibility while tailoring solutions for their customers. Instead of shoehorning consumers into a particular system, engineers can better customize what they’re offering. However, working with a wide range of microprocessors and microcontrollers also comes with greater challenges. Teams will have to port one project from one platform to the next. As a result, they must adapt to different peripherals, computational throughput, and power management systems, only to name a few. Crank brings a solution to customers that bypasses such issues. Thanks to its framework, companies can work on one application that will span across a wide range of devices. Developers can thus save money, reduce their time to market and enjoy greater flexibility.
Crank Storyboard: The Road Between MCU and MPU
Storyboard and STM32
The main challenge behind the use of multiple MCUs and MPUs comes from issues linked to portability. For example, moving from a microcontroller to a microprocessor usually demands a significant application rewrite. Even porting an application from one family of MCU to the other can have crippling effects on a company’s operations. Peripherals may be different, some hardware IPs may be missing, memory configuration may vary, all leading to incompatibilities. Crank circumvents all this by using runtime engines designed for specific platforms. Hence, instead of sweating code, engineers can focus on creating an exceptional experience (UX) for their end-users.
Another common problem for developers comes from the enormous work many have to put in to optimize their system. Adopting a solution such as Storyboard moves the optimization burden onto the runtime engine. For instance, the company offers a modular approach through the use of plugins. Developers can thus tailor the modules they run to avoid wasting resources.
On an STM32, it means the Storyboard framework adapts to the MCU’s hardware. Among other things, it can take advantage of the ChromART IP or customize the application’s memory footprint. Hence, moving from an MCU to an MPU becomes more straightforward since the framework adapts to the new architecture. For instance, the STM32MP1 has a 3D accelerator that opens the door to far richer interfaces. However, some cost-effective version of STM32MP1 come without the GPU. Yet, in all cases, Crank adapts its runtime to help engineers release to market faster. Similarly, moving from an MPU to an MCU is also vastly simpler. Developers must still keep in mind that a lower-power architecture will have lower performances. However, all the differences in operating systems, RAM management, and more, are now handled by the engine.
Storyboard and the Industry
A great example of the flexibility inherent to Storyboard is in its Lua scripting callbacks. Developers working on an MPU often use Lua because of its powerful and fast nature. However, Storyboard also enables programmers to switch to a C function callback to adapt to a more memory-restricted MCU. The feature is an example of how Storyboard uses a fixed data model to represent elements on screen rather than a code generation system. Crank’s paradigm also explains the framework’s flexibility, which, in turn, opens the door to new applications.
Crank shared how their teams are witnessing developers of entry-level systems use videos to improve the user experience. By employing a display and a flipbook-style interface, they can demonstrate how to use certain functionalities. Using Storyboard on an STM32 MCU can, therefore, vastly improve the experience without needing an expensive microprocessor that would blow up the bill of materials. Similarly, IoT products that previously only relied on STM32 MCUs are now adopting an STM32MP1 to benefit from the additional computational resources while using Storyboard to facilitate the transition and to reduce their time to market. Inversely, audio interface makers that relied on microprocessors for their interface may now adopt STM32 MCUs. Storyboard helps them transition to a more cost-effective system, thus opening them to new markets.
Crank Storyboard: The Journey From Proof-of-Concept to Product Launch
What to Do and Not to Do at the Beginning
As we sat down with Crank, the company had a few pieces of advice for engineers. One of them was to start with the build image. It’s very easy for teams to get bogged down in documentation or roadblocking implementation issues. Evaluation boards solve all these problems by offering a working proof-of-concept with replicable examples. They jumpstart a project, enabling designers to test their GUI early, which provides invaluable feedback and hastens development. Crank also explained that choosing a common starting platform for all projects reduces frictions. It is often simpler and more efficient to begin on a familiar machine and define the application’s specifications later, then to try to guess what a program will need early in the process.
On the Shoulder of Giants
Another essential piece of advice to keep in mind is to be wary of underlying complexities. Some companies may be reluctant to use a tool like Storyboard, and they may decide to do everything from scratch. However, ST and Crank work closely together because we know that optimization operations can get complex. Our collaboration ensures that anyone working on an STM32 product can extract all available performance without spending months or years on their source code. It also frees teams to work with their customers on features that will genuinely distinguish them. Moreover, working with Storyboard ensures teams can repurpose a GUI on a different platform without recompiling the codebase.
