ALLPCB
Overview
In today’s fast-paced embedded systems world, flexibility and adaptability are key. SEGGER introduced Embedded apps (emApps), similar to mobile apps, that can run on embedded systems.
How emApps Work
Apps are small, dynamic software modules that can be linked into device firmware either statically or dynamically. Dynamic linking is common, allowing users to download and add apps to existing firmware at any time.
Apps are executed by a compact, highly optimized piece of code in the firmware called the executor, which implements the instruction set of a virtual CPU. This extends device capabilities and makes devices more general-purpose, allowing them to adapt to new requirements and updates. In effect, apps turn embedded devices into embedded platforms.
Apps run in a sandboxed, protected environment that the underlying operating system can monitor. If an app attempts an unauthorized action, the executor suspends the app and returns control to the firmware, which decides how to handle the situation. This containment prevents a faulty app from destabilizing the rest of the system.
Basic Principles
To enable apps, the firmware must include a sandbox and an executor plus an API that exposes selected functionality to apps. To grant file system read access, for example, the firmware typically exposes three functions such as OpenFile, ReadFile, and CloseFile. Write access requires a WriteFile function.
How apps are loaded and in which context or thread they run depends on the firmware architecture. Multiple apps can run concurrently under the control of an RTOS, either on the same core or on different cores. Because the executor is invoked by the firmware, it can be used with any RTOS.
Each app has an isolated memory space. If an app crashes, it does not affect overall system stability, similar to how a crashed mobile or desktop app does not bring down the host OS. This isolation can simplify certification for safety-critical systems because peripheral control, such as display handling, can be moved into an app without necessarily being part of the certified core.
Memory Requirements
emApps increase flexibility while keeping memory overhead small. The executor, as part of the embedded firmware, typically requires 600 to 1000 bytes. There are ARM-optimized and portable C versions, allowing operation on almost any platform. Firmware API functions typically add 1 to 3 KB of footprint, depending on how many native capabilities are exposed to apps. This makes emApps viable even on smaller systems with, for example, 64 KB of flash, and the framework can be integrated into existing firmware with relative ease.
Code Density
The virtual CPU code density is very high, often exceeding the code density of the host CPU, particularly in RISC-V environments. This helps save program space, especially when apps are statically linked. A dedicated C compiler is used for the virtual CPU; other languages such as BASIC, Pascal, and Python can be used via C conversion tools.
Memory Protection and Sandbox
Apps can only access memory regions allocated by the firmware. While an app is active, the firmware supplies its memory. Any attempt to access memory outside the assigned region is intercepted, the executor returns control, and the firmware decides how to handle the violation.
Performance
Apps execute inside the firmware via the executor. The implemented instruction set is compact, so the number of virtual CPU instructions required to perform a given task is generally much lower than the number of host CPU instructions that would be needed. The virtual instruction stream can be executed efficiently on any CPU. By offloading compute-intensive work to the host CPU where appropriate, overall performance can approach that of native execution.
This approach is integrated into J-Link and Flasher product lines to allow the addition of new CPU support via apps. In Flasher Hub, apps can customize the web user interface, add new functionality, or change the UI language.
Applications and Ecosystem
Embedded applications across various industries can take advantage of this technique. emApps enable controlled, secure function expansion and provide a mechanism for third-party developers to contribute to the ecosystem.
