Platform Overview

This document provides an overview of the UNA Watch platform’s unique architecture and capabilities.

Unique architecture

Unlike traditional smartwatch platforms, UNA Watch apps are:

  • Pure Machine Code: Compiled ELF binaries executing directly in MCU memory

  • Position-Independent: Apps abstracted from kernel using PIC (Position-Independent Code)

  • Shared libc: Memory-efficient library sharing across all apps

  • Dual-Process: Service (background) + GUI (interface) process architecture

Platform Architecture

Core Concepts

Pure Machine Code Execution

UNA Watch apps are not interpreted or virtualized. They are compiled ARM Cortex-M ELF binaries that execute directly in the MCU memory. This provides:

  • Native Performance: Zero abstraction overhead.

  • Direct Hardware Access: Apps can interact with peripherals at MCU speeds.

  • Efficiency: Minimal memory and CPU footprint.

Position-Independent Code (PIC)

To allow apps to be loaded at any memory address without re-linking, the SDK uses Position-Independent Code.

  • Kernel Abstraction: Apps are completely abstracted from the kernel’s memory layout.

  • Dynamic Loading: The kernel can load, run, and unload apps on demand.

  • Process Isolation: No MMU, so the app can read entire MCU memory and execute whatever it want. Developers need to ensure that apps do not interfere with each other or the kernel.

Shared libc Integration

UNA Watch implements a shared libc architecture to save memory.

  • Common Base: All apps share the same standard library implementation provided by the kernel.

  • Reduced Footprint: Significant reduction in the size of each .uapp file.

  • C++ Support: Full support for modern C++ features (strings, vectors, etc.) via the shared library.

Dual-Process Model

Every UNA Watch app consists of two distinct components:

  1. Service Process: Handles background logic, sensors, and BLE.

  2. GUI Process: Handles user interface and interaction.

IPC Mechanisms

Communication between processes is handled via a high-performance message-passing system.

  • Kernel Pools: Messages are allocated from pre-defined kernel memory pools.

  • Type-Safe: Messages are strongly typed using C++ structures.

  • Asynchronous: Non-blocking message exchange for smooth UI performance.

Memory Management

  • Pool Allocation: Prevents heap fragmentation in long-running applications.

  • RAII Patterns: Automatic resource cleanup using modern C++ practices.

  • Protected Regions: Memory regions are protected to prevent unauthorized access.

Power Management

  • Deep Sleep: The kernel automatically enters low-power modes when idle.

  • Wake Sources: Apps uses common RTOS tehniques for manage cpu time: awating for messages from kernel or sleep().

  • Battery Optimization: Ajustable sampling rates and batching sensors samples.

Next Steps

For detailed SDK setup and build workflows, see SDK setup.

For hands-on app development tutorials, see HelloWorld tutorial.

For SDK APIs and interfaces, see SDK overview and architecture deep dive.