DEV Community

Cover image for UNA Watch (STM32U595) Architecture: FreeRTOS & C++ SDK Guide
EmbedSBC
EmbedSBC

Posted on Originally published at embedsbc.com

UNA Watch (STM32U595) Architecture: FreeRTOS & C++ SDK Guide

The UNA Watch (powered by the STMicroelectronics STM32U595) is a modular, open-source GPS smartwatch designed for custom wearable firmware development; it eliminates the proprietary black-box restrictions of commercial wearables via a public FreeRTOS kernel and native C++ SDK, though its IPX5 rating and 2.5MB on-chip RAM rule out aquatic use and memory-heavy edge workloads.

una-heart-rate-interface

una heart rate interface

How Does the UNA Watch Balance Six-Constellation GNSS Tracking with a 10-Day Runtime on a 280mAh Battery?

The UNA Watch achieves up to 10 days of standard operation or 20 hours of continuous GPS tracking from a 280mAh battery by pairing an ultra-low-power ST STM32U595 (Arm Cortex-M33) MCU with a reflective 1.2-inch Memory-in-Pixel (MIP) LCD.

In portable telematics and rugged wearable design, the RF front-end and display subsystem typically dominate the power budget. Compared to conventional smartwatches built around application processors (MPUs) and always-on OLED panels, the UNA Watch uses a microcontroller architecture and a 1.2-inch MIP LCD (240 × 240 resolution) to eliminate the current draw of static frame refreshes and high-frequency idle states, though this caps on-chip memory at 2.5MB RAM and requires activating an integrated LED backlight in low-ambient-light environments.

On the peripheral bus, environmental and biometric sensing channels interface directly with the ST STM32U595. The positioning subsystem supports six satellite constellations— GPS, GLONASS, Galileo, BeiDou, NavIC, and QZSS —working alongside an onboard accelerometer, gyroscope, magnetometer, barometric altimeter, temperature sensor, and optical heart rate sensor to form a complete 9-axis dead-reckoning (DR) and physiological monitoring hardware base. Wireless telemetry and power delivery are handled via Bluetooth LE 5.2 and a USB-C port, while user alerts rely on a haptic vibration motor and a piezoelectric buzzer.

una-gps-route-tracking

una gps route tracking

UNA Watch Hardware & Firmware Specifications

Subsystem Core Specification Engineering Details & Supported Protocols
Host MCU ST STM32U595 Arm Cortex-M33 core architecture
Memory & Storage 2.5MB RAM + 4GB eMMC On-chip SRAM paired with non-volatile eMMC flash
Display Panel 1.2-inch MIP LCD 240 × 240 resolution with integrated LED backlight
GNSS Positioning Multi-Constellation GNSS GPS / GLONASS / Galileo / BeiDou / NavIC / QZSS
Sensor Suite Motion & Biometrics Optical heart rate, accelerometer, gyroscope, magnetometer, barometric altimeter, temperature
Connectivity & I/O Bluetooth LE 5.2 / USB-C Android / iOS telemetry sync, charging, and .uapp binary sideloading
User Feedback Dual-Mode Actuation Haptic vibration motor + piezoelectric buzzer
Power & Ingress 280mAh Swappable / IPX5 Up to 10 days daily use / 20 hours continuous GPS; splash/rain resistant (not swim-proof)
Real-Time OS FreeRTOS Open-source kernel firmware; supports custom builds and flashing
Application Runtime Native C++ SDK (MIT License) Compiles to Arm Cortex-M ELF binaries (Position-Independent Code / PIC)
Toolchain & Simulators CMake + ST ARM GCC Windows (TouchGFX / Visual Studio); x86-64 Linux (GCC / SDL2)
Mechanics & Licensing Torx T3 Modular Assembly Enclosure and PCB design released under CC BY 4.0

How Does the UNA Watch Execute Native C++ Applications Dynamically Within a 2.5MB RAM Footprint?

The UNA Watch executes custom C++ applications directly on the microcontroller within a 2.5MB RAM budget by compiling code into Position-Independent Code (PIC) Arm Cortex-M ELF binaries on top of FreeRTOS and linking against shared system C libraries.

In standard Cortex-M firmware workflows, adding third-party applications typically requires statically linking user code against the RTOS kernel into a monolithic binary image, or running an interpreted runtime (such as MicroPython or JerryScript) at the expense of CPU cycles and SRAM overhead. Compared to monolithic static linking or script interpreters, the UNA Watch uses PIC ELF dynamic loading and shared C libraries to eliminate full-firmware reflashing for minor app updates while retaining native C++ execution speed—though developers must adhere to its packaging pipeline to compile .uapp bundles and sideload them over USB.

To prevent GUI rendering stalls from starving underlying sensor polling loops or triggering watchdog resets, the firmware enforces strict execution separation:

  • Decoupled Frontend/Backend Architecture: Custom user applications—including activity trackers, utilities, widgets, and watch faces—split background services from the graphical interface, communicating strictly via asynchronous message passing. This guarantees deterministic timing for sensor sampling and system service calls regardless of UI frame rate drops.
  • Cross-Platform Simulation & Build Pipeline: Developers build applications using CMake and ST's ARM GCC toolchain. Before deploying to target hardware, UI layouts and state machines can be verified using desktop simulators included in the SDK—running on TouchGFX and Visual Studio for Windows, or GCC and SDL2 on x86-64 Linux. Source repositories, firmware build instructions, and API references are maintained in the official SDK developer documentation, while companion Android and iOS apps handle activity syncing, fitness metrics, watch configuration, and Strava integration.

una-phone-app

How Do Modular Mechanics and Open Hardware Licensing Simplify Wearable Customization and Field Servicing?

The UNA Watch uses Torx T3 fasteners and releases its enclosure and PCB files under a CC BY 4.0 license, allowing engineers to swap batteries and displays non-destructively or modify board layouts without reverse-engineering.

Commercial wearables almost universally rely on permanent adhesive sealing to achieve deep water resistance, which makes battery replacement and hardware probing destructive processes. Compared to glued, sealed consumer smartwatches, the UNA Watch uses Torx T3 mechanical fasteners to eliminate heat-gun disassembly and ribbon-cable tear risks during maintenance, though this mechanical trade-off limits ingress protection to IPX5 (rated for rain and splashes only).

For commercial prototyping and open-source compliance, the platform separates its hardware and software licensing cleanly:

  1. Hardware Layer (CC BY 4.0): Mechanical CAD files and PCB layouts are published under the Creative Commons Attribution 4.0 license in the UNA Watch GitHub hardware repository, enabling hardware engineers to inspect signal routing or spin custom enclosures directly from source files.
  2. Software Layer (MIT License): The application-level C++ SDK is released under the MIT License alongside public kernel firmware source code, allowing engineering teams to modify FreeRTOS task scheduling, rewrite low-level sensor drivers, and distribute proprietary binaries without copyleft disclosure obligations.

Engineering Selection Boundaries (Target Use Cases vs. Hardware Constraints)

When evaluating the UNA Watch as a development platform or field terminal, engineering teams should weigh the following architectural boundaries:

  • Target Use Cases (Recommended Fit)
    • Multi-Sensor Fusion & Navigation Algorithm R&D: Projects requiring raw access to 6-constellation GNSS data paired with 9-axis IMU (accelerometer, gyroscope, magnetometer) and barometric altimeter streams for dead-reckoning or outdoor kinematic tracking.
    • Low-Power FreeRTOS / C++ Wearable Prototyping: Teams building custom watch faces, background telemetry daemons, or field-test apps on a Cortex-M33 budget while leveraging pre-built Android/iOS BLE sync pipelines and Strava integration under a permissive MIT license.
    • Serviceable & Custom-Enclosure Deployments: Hardware evaluations requiring rapid field replacement of the 280mAh battery or display module, or mechanical re-packaging using the CC BY 4.0 enclosure and PCB design files.
  • Hardware Constraints (When to Avoid)
    • Aquatic & Submersion Environments: Ingress protection is limited to IPX5. It handles rain and splashes, but must not be used for swimming, diving, or pressurized washdowns.
    • Memory-Intensive Edge Workloads: Constrained by 2.5MB on-chip RAM and an Arm Cortex-M33 core, the platform cannot boot embedded Linux or run memory-heavy computer vision or large local ML models.
    • Tool-Free Swapping or Contactless Charging: Disassembly requires a Torx T3 driver, and both charging and .uapp binary transfers rely exclusively on a physical USB-C connection.

una-packing-list

una packing list

Engineering FAQ

*Q: How does the UNA Watch run custom applications on the MCU while minimizing RAM usage?*

A: Applications are written in C++ and compiled via CMake and ARM GCC into Position-Independent Code (PIC) Arm Cortex-M ELF binaries, executing directly on the STM32U595 while linking against shared C libraries to reduce SRAM footprint.

*Q: What toolchain and simulator dependencies are required for Linux-based development?*

A: Compiling and packaging .uapp binaries requires CMake and ST's ARM GCC toolchain. The desktop simulator runs natively on x86-64 Linux using GCC and SDL2 (while Windows uses TouchGFX and Visual Studio).

*Q: What licensing terms govern custom hardware and firmware modifications on the UNA Watch?*

A: Enclosure and PCB designs are released under the Creative Commons Attribution 4.0 (CC BY 4.0) license, the C++ SDK is MIT-licensed, and the FreeRTOS kernel firmware source is publicly available for custom compilation.

Pricing & Availability

Originally introduced via a Kickstarter campaign in April 2025, the UNA Watch is now available through electronics distributor Pimoroni. The Charcoal edition is priced at $201 USD, with White and Teal colorways also available. Engineers can check stock and order directly via the Pimoroni product page.


Originally published on EmbedSBC — embedded systems, SBC and edge-AI hardware analysis.

Top comments (0)