How MuditaOS Brings Service‑Oriented Architecture to Embedded Phones

Project Overview

MuditaOS is an open‑source mobile operating system for the ultra‑minimalist Mudita Pure phone. The source code is hosted on GitHub at https://github.com/mudita/MuditaOS and is released under the GPL‑3.0 license.

Core functionality : basic communication services (calls, SMS, contacts) without a general‑purpose app ecosystem.

Target hardware : ARM Cortex‑M7 MCU paired with an E‑Ink display, optimized for extreme low‑power operation.

Technology stack : C++17, FreeRTOS, and a custom service framework; the codebase is roughly 500 k LOC.

Design philosophy : digital minimalism that emphasizes user attention and digital health.

https://github.com/mudita/MuditaOS

Core Mechanisms

MuditaOS replaces traditional task‑oriented scheduling with a service‑oriented architecture adapted for embedded constraints.

Service Manager

Each functional unit is implemented as an independent Service that runs in its own FreeRTOS task. All services inherit from the base class sys::Service and expose virtual methods, providing C++ type safety while allowing flexible extension.

Message‑Passing Mechanism

Services communicate through a type‑safe message queue. Every message carries an explicit type tag, and a variant of the Visitor pattern lets the message itself invoke the appropriate handler, eliminating large switch‑case blocks.

// Example of a type‑safe message definition
struct MessageBase { virtual void accept(MessageVisitor &v) = 0; };
struct CallRequest : MessageBase {
    std::string number;
    void accept(MessageVisitor &v) override { v.handle(*this); }
};

Inter‑Service Communication Flow

The message system is asynchronous: the sender posts a message and continues execution without blocking. This avoids task deadlock and keeps the system responsive on a resource‑limited MCU.

Service Lifecycle Management

Service startup and shutdown follow three disciplined rules:

Dependency checks guarantee that services start in the correct order.

Each service maintains a strict state machine (e.g., Created → Initialized → Running → Stopped).

Event‑notification callbacks broadcast state changes to any interested services.

// Simplified lifecycle handling
enum class ServiceState { Created, Initialized, Running, Stopped };
class MyService : public sys::Service {
    ServiceState state = ServiceState::Created;
public:
    void init() override { /* dependency checks */ state = ServiceState::Initialized; }
    void start() override { state = ServiceState::Running; notifyStateChange(); }
    void stop() override { state = ServiceState::Stopped; notifyStateChange(); }
};

Conclusion

MuditaOS demonstrates that modern service‑oriented architectural concepts can be successfully applied to a highly constrained embedded platform. The combination of independent FreeRTOS tasks, type‑safe asynchronous messaging, and disciplined lifecycle management yields a modular, extensible system while respecting the limited CPU, memory, and power budgets of the Mudita Pure hardware.