Harness Platform Flexibility for Rapid Development

June 25, 2025

Blog

Speed is of the essence in prototyping. The key to market success is to deploy applications that make new services possible and streamline those that already exist. Today’s embedded systems are becoming far richer in the functionality they deliver, exploiting technologies such as data analytics and machine learning to better handle real-time sensor data. They are also taking advantage of improvements in user-interface technology to make automated systems easier to set up and control.

Harnessing these additional capabilities often means using rapid-prototyping techniques. Developers want to try out different application scenarios to both determine feasibility and market acceptance. Early versions can go to customers to gauge how well the idea will work in the field. As the team refines the application concepts into reliable software, it will become clearer what functions the production will need. Some elements will need to be added, and others that are deemed unnecessary will need to be removed.

Prototyping and development need not take place on physical hardware targets, allowing work to start even before hardware is available. Much of the software can be developed on host and cloud environments where engineers can take advantage of the many simulation, debugging, and analysis tools supported by those environments. The obstacle to the flexibility that developers want to change hardware and move between different runtime environments lies in the difficulties that embedded applications face.

Embedded systems demand low-level access to I/O functions and often have real-time requirements that place far more weight on hardware dependencies. Dealing with changes in those hardware dependencies as code moves from server to target or across different targets as the hardware team optimises the configuration, gets in the way of rapid prototyping. Software engineers find they are spending too much time rewriting I/O access code and other functions that do not work as expected when the underlying platform changes.

Improvements to hardware standards have reduced some of the porting overhead. Standards such as SMARC provide a consistent pinout and I/O map for common peripherals. They have also created a vibrant market for readymade processor boards and I/O-expansion modules that have drastically reduced the need to design custom hardware before the prototyping phase can begin.

In principle, SMARC even makes it easier to switch between processor architectures and preserve the same I/O capability. This lets manufacturers take advantage more readily of performance and power-efficiency innovations made possible by the latest Arm and X86 architectures. That is, as long as the task of porting software from one to the other is as seamless as possible.

As well as providing access to many advanced software tools, the cloud environment has led to important innovations in software portability and convenience that can greatly smooth the process of moving from one hardware platform to another. One of the most important innovations is that of the container.

A container has some of the attributes of a virtual machine in that it isolates the hardware from the operating system and application code for a project. In the cloud environment, this image ensures that the operating system and library services the application needs are always available, no matter which server host is used to run the software. All I/O calls are abstracted so that accesses to a network, for example, do not need to change to work with different hardware interfaces. A major advantage of containers over virtual machines is that running an application in a container will run at the same speed using the same amount of memory as it would if it were running outside of a container (natively on the system), therefore improving runtime efficiency. Multiple containers running on a target share the host operating system kernel. But they are still functionally isolated from each other to prevent mutual interference.

Container technology underpins the SimpleSwitch framework for Tria’s family of SMARC modules. SimpleSwitch was designed to make creating embedded software as straightforward and fast as developing a smartphone app. Because it employs a standard way of exposing all hardware interfaces to the software running on the SimpleSwitch runtime environment, the software call to access an I2C bus or a GPIO port will be the same for an i.MX8M Mini module, an i.MX8M Plus or even a board hosting an Intel x86 processor.

As deliverables, the software is divided into three parts: the software development kit (SDK), base operating system images, and a registry of containers that contain many useful functions. The SDK supports three target architectures: the Arm-based i.MX8 family of processors from NXP, Intel x86, and QEMU.

QEMU is an important inclusion. It is a virtual machine that replicates the hardware interfaces of the target SMARC modules so that code designed for those modules can run on a host workstation or a cloud platform. This delivers a convenient and cost-effective method for engaging large teams of engineers in the same project. There is no need for those developers to wait for access to a hardware module that might be needed for testing or customer evaluation. They can write and test code on the host and expect it to work the same way on the physical target.

Each SimpleSwitch image provides a base operating system able to host the containers. The image is sufficient to boot the board and set up an attached display, as well as allowing the developer to use SSH sessions to access its internal functions over a network connection.

Within the base image is a standard Linux filesystem built with Yocto, accompanied by two software stacks. The first stack is SimpleCoreIO, a hardware abstraction layer that delivers a single, consistent way to access any of the SMARC module’s I/O. The second stack is the container manager, which provides a way to organise both user containers. It provides a collection of pre-packaged templates that support Python, Flutter, and the Qt runtime environments. Using these pre-packaged containers, software engineers can take advantage of the rapid development support these environments provide.

The container registry gives developers access to a large range of pre-packaged software stacks that deliver additional services that ease the task of creating advanced systems for the Internet of Things (IoT). The registry includes modules for Chromium, COG, Mosquito, and MQTT. A further module in the container registry is IoT Connect, which enables data management and data ingestion for IoT applications. In a few steps, a developer can have a device collect and relay telemetry data to the cloud by incorporating its container from the registry and setting up access credentials on the target.

As hardware decisions change and software calls for modules to be swapped in and out, the combination of container technology and the support features of the SDK and registry enables these modifications to happen quickly and with minimal fuss.

As the project nears completion, developers can then consider the industrial runtime environment that will be needed. The architecture of SimpleSwitch is optimised for prototyping, with features designed to enable easy hardware changes. The complementary Embedded Kit delivers production-ready features alongside utilities that are valuable to systems in the field. These include support for enhanced security through features such as secured boot and long-term maintenance capabilities with support for over-the-air (OTA) updates.

In summary, rapid prototyping is now a crucial part of embedded and IoT systems development. By choosing a software environment that allows for quick modifications to both hardware and software and that leverages the capabilities of a rich platform such as SMARC, project teams can ensure they do not need to struggle with porting issues. They can instead focus on delivering application value.

For more information, visit tria-technologies.com.