folder cleanup

Signed-off-by: Peter Siegmund <developer@mars3142.org>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/esp32_build.yml

@@ -19,8 +19,8 @@ jobs:
   build:
     strategy:
       matrix:
-        idf_ver: [release-v5.4, latest]
-        idf_target: [esp32c3, esp32h2, esp32s3, esp32p4]
+        idf_ver: [release-v5.4, release-v5.5, latest]
+        idf_target: [esp32s3]
 
     runs-on: ubuntu-latest
     timeout-minutes: 30
@@ -32,11 +32,12 @@ jobs:
           submodules: "recursive"
 
       - name: Delete CMakeLists.txt in components (only used for simulator build)
-        run: rm components/CMakeLists.txt
+        run: rm firmware/components/CMakeLists.txt
 
       - name: ESP-IDF build
         uses: espressif/esp-idf-ci-action@v1
         with:
           esp_idf_version: ${{ matrix.idf_ver }}
           target: ${{ matrix.idf_target }}
+          path: firmware
           command: idf.py -DSDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.release" build

.gitignore

@@ -1,40 +1,22 @@
-# esp-idf
-build/
-managed_components/
-sdkconfig
-sdkconfig.old
-dependencies.lock
-config.env
-kconfigs_projbuild.in
-kconfigs.in
-config/
+# Created by https://www.toptal.com/developers/gitignore/api/visualstudiocode
+# Edit at https://www.toptal.com/developers/gitignore?templates=visualstudiocode
 
-# cmake
-cmake-build-debug
-CMakeCache.txt
-cmake_install.cmake
-install_manifest.txt
-CMakeFiles/
-CTestTestfile.cmake
-Makefile
-CMakeScripts
-compile_commands.json
-
-# They ignored Idea (Webstorm) completely
-.idea/
-.cache/
-
-# However, they kept the following 4 files version controlled
+### VisualStudioCode ###
 .vscode/*
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
-.history/*
-__pycache__
-_deps/
-.cmake/
-.ninja_*
-bin/
-components/**/*.a
-*.ninja
-Testing/*
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/visualstudiocode

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "library"]
+	path = hardware/library
+	url = https://git.mars3142.dev/mars3142/kicad_library.git

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+warnemuende.lighthouses@mars3142.org.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

README.md

@@ -1,15 +1,3 @@
-## Systen Control
+# System Control
 
-### ESP32-S3 (folder: main)
-
-This is an implementation of my custom system control project (custom pcb with Lolin ESP32-S3 Mini) and LED strip.
-
-The build process is straight forward with ESP-IDF. We used version 5.4 while development and the github actions tried to compile for multiple ESP-IDF versions, so we are safe.
-
-### Desktop (folder: src)
-
-It's included also a desktop application (with SDL3), so you can test the project without any MCU.
-
-### Global Information
-
-The projects can be generated from the root, because here is the starting CMakeLists.txt file.
+See the [wiki](https://wiki.mars3142.dev/project/maerklin/system_control/start) for more information.

components/insa/include/ui/ScreenSaver.h

@@ -1,397 +0,0 @@
-/**
- * @file ScreenSaver.h
- * @brief Animated screensaver implementation with starfield effect
- * @details This header defines the ScreenSaver class which provides an animated
- *          starfield screensaver that activates during periods of user inactivity.
- *          The screensaver displays moving stars to prevent screen burn-in while
- *          providing visual feedback that the system is still active and responsive.
- * @author System Control Team
- * @date 2025-06-14
- */
-
-#pragma once
-
-#include "MenuOptions.h"
-#include "common/Widget.h"
-#include <vector>
-
-/**
- * @class ScreenSaver
- * @brief Animated starfield screensaver widget for system idle periods
- * @details This final class inherits from Widget and implements an interactive
- *          screensaver featuring an animated starfield effect. The screensaver
- *          activates automatically during periods of user inactivity to prevent
- *          screen burn-in while maintaining visual indication of system activity.
- * 
- * The ScreenSaver class provides:
- * - Dynamic starfield animation with pseudo-3D depth effect
- * - Configurable star count and animation speed parameters
- * - Automatic activation during idle periods
- * - Immediate deactivation on any user input
- * - Smooth star movement and regeneration system
- * - Memory-efficient star management with object pooling
- * 
- * Key features include:
- * - 3D-style starfield with depth-based speed variation
- * - Continuous star recycling for infinite animation
- * - Responsive user input handling for immediate exit
- * - Optimized rendering for smooth animation performance
- * - Configurable animation parameters for different visual effects
- * 
- * The starfield effect simulates movement through space by moving stars
- * from the center outward at speeds proportional to their depth (z-coordinate).
- * Stars that move beyond the screen boundaries are automatically recycled
- * to new random positions, creating an infinite scrolling effect.
- * 
- * @note This class is marked as final and cannot be inherited from.
- * @note The screensaver automatically exits on any button press, returning
- *       control to the previous screen or main menu interface.
- * 
- * @see Widget for base widget functionality
- * @see menu_options_t for configuration structure
- * @see InactivityTracker for automatic screensaver activation
- */
-class ScreenSaver final : public Widget
-{
-  public:
-    /**
-     * @brief Constructs the screensaver with specified configuration
-     * @param options Pointer to menu options configuration structure
-     * 
-     * @pre options must not be nullptr and must remain valid for the screensaver's lifetime
-     * @pre options->u8g2 must be initialized and ready for graphics operations
-     * @pre Screen transition callbacks in options must be properly configured
-     * @post ScreenSaver is initialized with starfield ready for animation
-     * 
-     * @details The constructor initializes the screensaver by:
-     *          - Setting up the star field with initial random positions
-     *          - Configuring animation timing and speed parameters
-     *          - Preparing graphics context for efficient rendering
-     *          - Initializing the animation counter for smooth timing
-     *          - Allocating and positioning all star objects
-     * 
-     * During initialization, all stars are placed at random positions within
-     * the 3D space defined by Z_NEAR and Z_FAR constants. Each star receives
-     * random x, y coordinates and a z-depth that determines its movement speed
-     * and visual appearance. The animation system is prepared for immediate
-     * activation when the screensaver becomes active.
-     * 
-     * @note The screensaver does not take ownership of the options structure
-     *       and assumes it remains valid throughout the screensaver's lifetime.
-     * @note Initial star positions are randomized to create immediate visual
-     *       interest when the screensaver first activates.
-     * 
-     * @see Widget::Widget for base class construction details
-     * @see initStars for star field initialization process
-     */
-    explicit ScreenSaver(menu_options_t *options);
-
-    /**
-     * @brief Updates the screensaver animation and star positions
-     * @param dt Delta time in milliseconds since the last update call
-     * 
-     * @details Overrides the base Widget update method to handle screensaver-specific
-     *          animation logic including:
-     *          - Advancing the animation counter for smooth timing control
-     *          - Updating individual star positions based on their speed and depth
-     *          - Moving stars outward from center based on their z-coordinate
-     *          - Recycling stars that move beyond screen boundaries
-     *          - Maintaining consistent animation frame rate regardless of system load
-     * 
-     * The update method implements the core starfield animation by:
-     * - Incrementing each star's position based on its depth-determined speed
-     * - Checking boundary conditions for stars moving off-screen
-     * - Resetting off-screen stars to new random positions near the center
-     * - Applying speed multipliers for smooth, consistent motion
-     * - Managing the animation counter for timing-dependent effects
-     * 
-     * Star movement calculation:
-     * - Stars closer to the camera (smaller z values) move faster
-     * - Movement speed is inversely proportional to z-coordinate
-     * - Stars maintain consistent outward direction from screen center
-     * - Boundary checking ensures smooth recycling without visual gaps
-     * 
-     * @note This method is called every frame while the screensaver is active
-     *       and must be efficient to maintain smooth 60+ FPS animation.
-     * @note The animation continues indefinitely until user input is received.
-     * 
-     * @see Widget::update for the base update interface
-     * @see resetStar for star recycling implementation
-     */
-    void update(uint64_t dt) override;
-    
-    /**
-     * @brief Renders the animated starfield to the display
-     * 
-     * @details Overrides the base Widget render method to draw the animated starfield
-     *          effect. The rendering process includes:
-     *          - Clearing the display buffer for clean animation frames
-     *          - Calculating screen positions for each star based on 3D coordinates
-     *          - Applying perspective projection to simulate depth
-     *          - Drawing stars with size/brightness based on distance
-     *          - Optimizing drawing operations for smooth frame rates
-     * 
-     * The render method creates a convincing 3D starfield effect by:
-     * - Converting 3D star coordinates to 2D screen positions
-     * - Scaling star positions based on perspective projection
-     * - Varying star appearance (size, brightness) based on depth
-     * - Drawing only stars within the visible screen area
-     * - Using efficient drawing primitives for optimal performance
-     * 
-     * Rendering optimizations include:
-     * - Culling stars outside the visible area
-     * - Using simple pixel/point drawing for maximum speed
-     * - Minimizing graphics context switches
-     * - Batching drawing operations where possible
-     * 
-     * The visual effect simulates movement through a star field by:
-     * - Making distant stars appear smaller and dimmer
-     * - Scaling star positions relative to screen center
-     * - Creating smooth motion blur effects for fast-moving stars
-     * 
-     * @pre u8g2 display context must be initialized and ready for drawing
-     * @post Starfield animation frame is drawn to the display buffer
-     * 
-     * @note This method is called every frame and must be highly optimized
-     *       to maintain smooth animation performance on embedded systems.
-     * @note The visual design provides an engaging screensaver that clearly
-     *       indicates system activity while preventing screen burn-in.
-     * 
-     * @see Widget::render for the base render interface
-     */
-    void render() override;
-    
-    /**
-     * @brief Handles user input to exit the screensaver immediately
-     * @param button The type of button that was pressed by the user
-     * 
-     * @details Overrides the base Widget button handling to provide immediate
-     *          screensaver exit functionality. Any button press while the screensaver
-     *          is active will:
-     *          - Immediately terminate the screensaver animation
-     *          - Return to the previous screen or main menu
-     *          - Reset any inactivity timers to prevent immediate reactivation
-     *          - Ensure responsive system behavior for user interaction
-     * 
-     * The method handles all button types uniformly since the screensaver should
-     * exit on any user input regardless of the specific button pressed. This
-     * ensures maximum responsiveness and intuitive behavior - users expect any
-     * interaction to wake the system from screensaver mode.
-     * 
-     * Button handling includes:
-     * - Immediate screensaver termination regardless of button type
-     * - Automatic transition back to the previous active screen
-     * - Inactivity timer reset to prevent immediate screensaver reactivation
-     * - Proper state cleanup to ensure system stability
-     * 
-     * @note This method ensures the screensaver never interferes with normal
-     *       system operation - any user input immediately restores full functionality.
-     * @note The screensaver exit process is designed to be instantaneous to
-     *       provide the most responsive user experience possible.
-     * 
-     * @see Widget::onButtonClicked for the base input handling interface
-     * @see ButtonType for available button input types
-     */
-    void onButtonClicked(ButtonType button) override;
-
-  private:
-    /**
-     * @struct Star
-     * @brief Individual star object structure for starfield animation
-     * @details Defines the properties and state of a single star in the animated
-     *          starfield. Each star maintains its position in 3D space and movement
-     *          characteristics needed for realistic animation and perspective effects.
-     * 
-     * The Star structure contains:
-     * - 3D spatial coordinates (x, y, z) for position tracking
-     * - Individual speed multiplier for varied animation effects
-     * - All data needed for perspective projection and movement calculation
-     * 
-     * Star coordinate system:
-     * - x, y: Screen-relative coordinates (can be negative for off-screen positioning)
-     * - z: Depth coordinate determining speed and perspective (Z_NEAR to Z_FAR range)
-     * - speed: Individual multiplier for varied star movement rates
-     * 
-     * @note This structure is designed for efficient memory usage and fast
-     *       mathematical operations during animation updates.
-     * @note All coordinates use float precision for smooth animation interpolation.
-     */
-    struct Star
-    {
-        float x;        ///< Horizontal position coordinate (screen-relative)
-        float y;        ///< Vertical position coordinate (screen-relative)  
-        float z;        ///< Depth coordinate (determines speed and perspective)
-        float speed;    ///< Individual speed multiplier for animation variation
-    };
-
-    /**
-     * @brief Pointer to menu options configuration structure
-     * @details Stores a reference to the menu configuration passed during construction.
-     *          Provides access to the display context for rendering operations and
-     *          screen transition callbacks for exiting the screensaver on user input.
-     * 
-     * The configuration enables:
-     * - Display context (u8g2) for starfield graphics rendering
-     * - Screen transition callbacks for returning to previous screen
-     * - System integration for proper screensaver lifecycle management
-     * 
-     * @note This pointer is not owned by the ScreenSaver and must remain valid
-     *       throughout the screensaver's lifetime.
-     */
-    menu_options_t *m_options;
-    
-    /**
-     * @brief Animation timing counter for smooth frame rate control
-     * @details Tracks elapsed time for animation timing and frame rate calculations.
-     *          Used to ensure consistent star movement regardless of system load
-     *          variations and to provide smooth interpolation between animation frames.
-     * 
-     * The counter enables:
-     * - Frame rate independent animation timing
-     * - Smooth interpolation for fluid star movement
-     * - Consistent animation speed across different hardware platforms
-     * - Precise timing control for animation effects
-     */
-    uint64_t m_animationCounter;
-    
-    /**
-     * @brief Vector container for all star objects in the starfield
-     * @details Manages the collection of Star objects that comprise the animated
-     *          starfield effect. The vector provides efficient storage and iteration
-     *          for the star animation system while maintaining good cache locality
-     *          for optimal performance during update and render operations.
-     * 
-     * The vector contains:
-     * - Fixed number of Star objects (NUM_STARS) allocated at initialization
-     * - Contiguous memory layout for efficient iteration during animation
-     * - Dynamic management capabilities for potential future enhancements
-     * 
-     * @note The vector size is fixed at construction to avoid memory allocations
-     *       during animation, ensuring consistent frame timing performance.
-     */
-    std::vector<Star> m_stars;
-
-    /**
-     * @brief Total number of stars in the animated starfield
-     * @details Defines the constant number of star objects that will be created
-     *          and animated in the starfield effect. This value balances visual
-     *          richness with performance requirements for smooth animation.
-     * 
-     * The star count affects:
-     * - Visual density and richness of the starfield effect  
-     * - Performance requirements for update and rendering operations
-     * - Memory usage for star object storage
-     * - Overall visual impact of the screensaver
-     * 
-     * @note This value is tuned for optimal performance on target hardware
-     *       while providing an engaging visual effect.
-     */
-    static constexpr int NUM_STARS = 10;
-    
-    /**
-     * @brief Global speed multiplier for star animation
-     * @details Controls the overall speed of star movement in the starfield animation.
-     *          This multiplier is applied to all star movement calculations to provide
-     *          consistent, smooth animation at an appropriate visual speed.
-     * 
-     * The speed multiplier affects:
-     * - Overall pace of the starfield animation
-     * - Visual impact and engagement level of the screensaver
-     * - Performance requirements for smooth animation
-     * - User perception of system responsiveness
-     * 
-     * @note This value is carefully tuned to provide engaging animation without
-     *       being distracting or causing motion sickness effects.
-     */
-    static constexpr float SPEED_MULTIPLIER = 0.02f;
-    
-    /**
-     * @brief Near clipping plane for 3D starfield depth range
-     * @details Defines the closest distance (minimum z-coordinate) at which stars
-     *          can exist in the 3D starfield space. Stars closer than this distance
-     *          are considered too close to the viewer and are recycled to new positions.
-     * 
-     * The near plane affects:
-     * - Minimum depth for star positioning and recycling
-     * - Perspective calculation range for realistic depth effects
-     * - Star recycling triggers for continuous animation
-     * - Visual depth range of the starfield effect
-     * 
-     * @note This value works with Z_FAR to define the 3D space within which
-     *       stars exist and animate, creating realistic depth perception.
-     */
-    static constexpr float Z_NEAR = 0.1f;
-    
-    /**
-     * @brief Far clipping plane for 3D starfield depth range  
-     * @details Defines the farthest distance (maximum z-coordinate) at which stars
-     *          can exist in the 3D starfield space. This establishes the back
-     *          boundary of the starfield volume and affects initial star placement.
-     * 
-     * The far plane affects:
-     * - Maximum depth for initial star positioning
-     * - Perspective calculation range for depth effects
-     * - Visual depth range and scale of the starfield
-     * - Initial star placement during system initialization
-     * 
-     * @note This value works with Z_NEAR to create a realistic 3D space
-     *       that provides convincing depth perception in the starfield animation.
-     */
-    static constexpr float Z_FAR = 10.0f;
-
-    /**
-     * @brief Initializes all stars with random positions and properties
-     * @details Private helper method that sets up the initial starfield by placing
-     *          all stars at random positions within the defined 3D space. Called
-     *          during construction to prepare the starfield for immediate animation.
-     * 
-     * The initialization process:
-     * - Assigns random x, y coordinates within screen boundaries
-     * - Sets random z-depth within the Z_NEAR to Z_FAR range
-     * - Configures individual speed multipliers for animation variation
-     * - Ensures even distribution of stars throughout the 3D volume
-     * 
-     * Random placement creates:
-     * - Natural, non-uniform star distribution for realistic appearance
-     * - Varied star depths for convincing 3D perspective effects
-     * - Immediate visual interest when screensaver first activates
-     * - Foundation for smooth continuous animation
-     * 
-     * @note This method is called only once during construction to establish
-     *       the initial starfield state before animation begins.
-     * 
-     * @see resetStar for individual star repositioning during animation
-     */
-    void initStars();
-    
-    /**
-     * @brief Resets a single star to a new random position for recycling
-     * @param star Reference to the Star object to be reset and repositioned
-     * 
-     * @details Private helper method that recycles individual stars that have
-     *          moved beyond the visible screen boundaries. This enables infinite
-     *          starfield animation by continuously introducing new stars while
-     *          removing those that are no longer visible.
-     * 
-     * The reset process:
-     * - Places the star at a new random position near the screen center
-     * - Assigns a new random depth (z-coordinate) for varied movement speed
-     * - Configures new speed multiplier for animation variation
-     * - Ensures smooth transition without visual discontinuities
-     * 
-     * Star recycling maintains:
-     * - Continuous starfield animation without visual gaps
-     * - Consistent star count throughout animation lifecycle
-     * - Varied star properties for natural, non-repetitive effects
-     * - Efficient memory usage through object reuse
-     * 
-     * @pre star parameter must be a valid Star object reference
-     * @post star object is repositioned with new random properties ready for animation
-     * 
-     * @note This method is called frequently during animation as stars move
-     *       off-screen and must be efficient to maintain smooth frame rates.
-     * @note The repositioning algorithm ensures stars appear to emerge naturally
-     *       from the center of the starfield for convincing 3D movement effects.
-     */
-    void resetStar(Star &star);
-};

components/insa/src/ui/ScreenSaver.cpp

@@ -1,93 +0,0 @@
-#include "ui/ScreenSaver.h"
-#include <cmath>
-
-ScreenSaver::ScreenSaver(menu_options_t *options) : Widget(options->u8g2), m_options(options), m_animationCounter(0)
-{
-    initStars();
-}
-
-void ScreenSaver::initStars()
-{
-    m_stars.resize(NUM_STARS);
-
-    for (auto &star : m_stars)
-    {
-        resetStar(star);
-        star.z = Z_NEAR + (static_cast<float>(rand()) / RAND_MAX) * (Z_FAR - Z_NEAR);
-    }
-}
-
-void ScreenSaver::resetStar(Star &star)
-{
-    star.x = (static_cast<float>(rand()) / RAND_MAX - 0.5f) * 2.0f;
-    star.y = (static_cast<float>(rand()) / RAND_MAX - 0.5f) * 2.0f;
-    star.z = Z_FAR;
-    star.speed = 0.5f + (static_cast<float>(rand()) / RAND_MAX) * 1.5f;
-}
-
-void ScreenSaver::update(const uint64_t dt)
-{
-    m_animationCounter += dt;
-
-    if (m_animationCounter > 8)
-    {
-        m_animationCounter = 0;
-
-        for (auto &star : m_stars)
-        {
-            star.z -= star.speed * SPEED_MULTIPLIER;
-
-            if (star.z < Z_NEAR)
-            {
-                resetStar(star);
-            }
-        }
-    }
-}
-
-void ScreenSaver::render()
-{
-    // Verwende Page-Buffer Mode statt Full-Buffer für bessere Performance
-    // Schwarzer Hintergrund
-    u8g2_SetDrawColor(u8g2, 0);
-    u8g2_DrawBox(u8g2, 0, 0, u8g2->width, u8g2->height);
-    u8g2_SetDrawColor(u8g2, 1);
-
-    const int centerX = u8g2->width / 2;
-    const int centerY = u8g2->height / 2;
-
-    // Zeichne nur sichtbare Sterne (Clipping)
-    for (const auto &star : m_stars)
-    {
-        // 3D zu 2D Projektion
-        int screenX = centerX + static_cast<int>((star.x / star.z) * centerX);
-        int screenY = centerY + static_cast<int>((star.y / star.z) * centerY);
-
-        // Frühe Prüfung für Performance
-        if (screenX < -5 || screenX >= u8g2->width + 5 || screenY < -5 || screenY >= u8g2->height + 5)
-        {
-            continue;
-        }
-
-        // Vereinfachte Sterndarstellung für bessere Performance
-        int size = static_cast<int>((1.0f - (star.z - Z_NEAR) / (Z_FAR - Z_NEAR)) * 2.0f);
-
-        if (size <= 0)
-        {
-            u8g2_DrawPixel(u8g2, screenX, screenY);
-        }
-        else
-        {
-            // Verwende u8g2_DrawCircle für größere Sterne (schneller)
-            u8g2_DrawCircle(u8g2, screenX, screenY, size, U8G2_DRAW_ALL);
-        }
-    }
-}
-
-void ScreenSaver::onButtonClicked(ButtonType button)
-{
-    if (m_options && m_options->popScreen)
-    {
-        m_options->popScreen();
-    }
-}

firmware/.gitignore

@@ -0,0 +1,40 @@
+# esp-idf
+build/
+build-release/
+managed_components/
+sdkconfig
+sdkconfig.old
+dependencies.lock
+config.env
+kconfigs_projbuild.in
+kconfigs.in
+config/
+
+# cmake
+cmake-build-debug
+CMakeCache.txt
+cmake_install.cmake
+install_manifest.txt
+CMakeFiles/
+CTestTestfile.cmake
+CMakeScripts
+compile_commands.json
+
+# They ignored Idea (Webstorm) completely
+.idea/
+.cache/
+
+# However, they kept the following 4 files version controlled
+.vscode/*
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+__pycache__
+_deps/
+.cmake/
+.ninja_*
+bin/
+components/**/*.a
+*.ninja
+Testing/*

firmware/CMakeLists.txt

@@ -58,14 +58,12 @@ else ()
             WIN32 MACOSX_BUNDLE
             ${CMAKE_SOURCE_DIR}/main.cpp
             ${CMAKE_SOURCE_DIR}/Common.cpp
-            ${CMAKE_SOURCE_DIR}/debug/DebugOverlay.cpp
+            ${CMAKE_SOURCE_DIR}/debug/debug_overlay.cpp
             ${CMAKE_SOURCE_DIR}/hal/u8x8_hal_sdl.cpp
-            ${CMAKE_SOURCE_DIR}/manager/PersistenceManager.cpp
             ${CMAKE_SOURCE_DIR}/manager/ResourceManager.cpp
             ${CMAKE_SOURCE_DIR}/model/AppContext.cpp
             ${CMAKE_SOURCE_DIR}/model/Window.cpp
             ${CMAKE_SOURCE_DIR}/ui/Device.cpp
-            ${CMAKE_SOURCE_DIR}/ui/Matrix.cpp
             ${CMAKE_SOURCE_DIR}/ui/UIWidget.cpp
             ${CMAKE_SOURCE_DIR}/ui/widgets/Button.cpp
             ${CMAKE_SOURCE_DIR}/ui/widgets/D_Pad.cpp
@@ -98,6 +96,8 @@ else ()
     target_link_libraries(${PROJECT_NAME} PRIVATE
             ImGui
             insa
+            led-manager
+            persistence-manager
             SDL3::SDL3
             SDL3_image::SDL3_image
             SDL3_ttf::SDL3_ttf

firmware/LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+0. Definitions.
+
+"This License" refers to version 3 of the GNU Affero General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+1. Source Code.
+
+The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+The Corresponding Source for a work in source code form is that
+same work.
+
+2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+13. Remote Network Interaction; Use with the GNU General Public License.
+
+Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

firmware/Makefile

@@ -0,0 +1,2 @@
+release:
+	idf.py -B build-release -DSDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.release" fullclean build

firmware/README.md

@@ -0,0 +1,15 @@
+## Systen Control
+
+### ESP32-S3 (folder: main)
+
+This is an implementation of my custom system control project (custom pcb with Lolin ESP32-S3 Mini) and LED strip.
+
+The build process is straight forward with ESP-IDF. We used version 5.4 while development and the github actions tried to compile for multiple ESP-IDF versions, so we are safe.
+
+### Desktop (folder: src)
+
+It's included also a desktop application (with SDL3), so you can test the project without any MCU.
+
+### Global Information
+
+The projects can be generated from the root, because here is the starting CMakeLists.txt file.

firmware/components/CMakeLists.txt

@@ -3,6 +3,8 @@ if (NOT DEFINED ENV{IDF_PATH})
 
     add_subdirectory(imgui)
     add_subdirectory(insa)
+    add_subdirectory(led-manager)
+    add_subdirectory(persistence-manager)
 
     target_link_libraries(components INTERFACE ImGui)
 endif ()

firmware/components/insa/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Definiere die Quelldateien in einer Variable
+# Define the source files in a variable
 set(SOURCE_FILES
     src/common/InactivityTracker.cpp
     src/common/Menu.cpp
@@ -8,6 +8,7 @@ set(SOURCE_FILES
     src/ui/LightMenu.cpp
     src/ui/LightSettingsMenu.cpp
     src/ui/MainMenu.cpp
+    src/ui/ClockScreenSaver.cpp
     src/ui/ScreenSaver.cpp
     src/ui/SettingsMenu.cpp
     src/ui/SplashScreen.cpp
@@ -16,12 +17,11 @@ set(SOURCE_FILES
 if (DEFINED ENV{IDF_PATH})
     idf_component_register(SRCS
             ${SOURCE_FILES}
-            src/common/PersistenceManager.cpp
             INCLUDE_DIRS "include"
-            REQUIRES
-                nvs_flash
             PRIV_REQUIRES
                 u8g2
+                led-manager
+                persistence-manager
     )
     return()
 endif ()
@@ -39,4 +39,6 @@ target_include_directories(${PROJECT_NAME} PUBLIC include)
 
 target_link_libraries(${PROJECT_NAME} PRIVATE
         u8g2
+        led-manager
+        persistence-manager
 )

firmware/components/insa/include/MenuOptions.h

@@ -17,7 +17,7 @@
 
 // Project-specific headers
 #include "common/Widget.h"
-#include "common/IPersistenceManager.h"
+#include "IPersistenceManager.h"
 #include "u8g2.h"
 
 class MenuItem;

firmware/components/insa/include/common/InactivityTracker.h

@@ -91,7 +91,7 @@ class InactivityTracker
      * });
      * @endcode
      */
-    InactivityTracker(uint64_t timeoutMs, std::function<void()> onTimeout);
+    InactivityTracker(uint64_t timeoutMs, const std::function<void()> &onTimeout);
 
     /**
      * @brief Updates the inactivity timer and checks for timeout conditions

firmware/components/insa/include/data/roads.h

@@ -0,0 +1,23 @@
+#define road_horizontal_width 16
+#define road_horizontal_height 16
+static unsigned char road_horizontal_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                               0x00, 0x00, 0x00, 0x8c, 0xc7, 0x8c, 0xc7, 0x00, 0x00, 0x00, 0x00,
+                                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+#define road_vertical_width 16
+#define road_vertical_height 16
+static unsigned char road_vertical_bits[] = {0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+                                             0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00,
+                                             0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00};
+
+#define road_t_up_width 16
+#define road_t_up_height 16
+static unsigned char road_t_up_bits[] = {0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
+                                         0x03, 0xcc, 0xcf, 0xcc, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+#define road_t_crossing_width 16
+#define road_t_crossing_height 16
+static unsigned char road_t_crossing_bits[] = {0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x80,
+                                               0x01, 0xe6, 0x67, 0xe6, 0x67, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00,
+                                               0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00};

firmware/components/insa/include/data/vehicles.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#define car_width 16
+#define car_height 16
+const unsigned char car_left_bits []  = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0xf0, 0x0f, 0xee, 0x77, 0xee, 0x77, 0xee, 0x77,
+    0x2e, 0x74, 0xde, 0x78, 0x02, 0x40, 0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00
+};
+const unsigned char car_right_bits []  = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0xf0, 0x0f, 0xee, 0x77, 0xee, 0x77, 0xee, 0x77,
+    0x2e, 0x74, 0x1e, 0x7b, 0x02, 0x40, 0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00
+};
+
+#define convertable_width 16
+#define convertable_height 16
+static unsigned char convertable_left_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x30, 0x0c, 0xee,
+                                                0x77, 0x2e, 0x74, 0xae, 0x75, 0xae, 0x75, 0xfe, 0x7f, 0x82, 0x41,
+                                                0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00};
+static unsigned char convertable_right_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x30, 0x0c, 0xee,
+                                                 0x77, 0x2e, 0x74, 0xae, 0x75, 0xae, 0x75, 0xfe, 0x7f, 0x82, 0x41,
+                                                 0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00};
+
+#define lorry_width 32
+#define lorry_height 16
+const unsigned char lorry_left_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0xe0,
+                                         0x0b, 0x00, 0x00, 0xf0, 0x0b, 0x00, 0x00, 0xee, 0x0b, 0x00, 0x00, 0xee, 0x0f,
+                                         0xbc, 0x07, 0x2e, 0xfa, 0xff, 0x7f, 0xae, 0xfa, 0xff, 0x7f, 0xbe, 0x0a, 0x00,
+                                         0x60, 0x02, 0x0a, 0x00, 0x60, 0x3c, 0x0a, 0xbc, 0x67, 0x42, 0xfe, 0x43, 0x78,
+                                         0xda, 0xff, 0x5b, 0x7b, 0x18, 0x00, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00};
+const unsigned char lorry_right_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+                                          0x00, 0xd0, 0x07, 0x00, 0x00, 0xd0, 0x0f, 0x00, 0x00, 0xd0, 0x77, 0xe0, 0x3d,
+                                          0xf0, 0x77, 0xfe, 0xff, 0x5f, 0x74, 0xfe, 0xff, 0x5f, 0x75, 0x06, 0x00, 0x50,
+                                          0x7d, 0x06, 0x00, 0x50, 0x40, 0xe6, 0x3d, 0x50, 0x3c, 0x1e, 0xc2, 0x7f, 0x42,
+                                          0xde, 0xda, 0xff, 0x5b, 0xc0, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00};
+#define suv_width 16
+#define suv_height 16
+const unsigned char suv_left_bits[] = {0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0xf0, 0x0f, 0xee, 0x77, 0xee,
+                                       0x77, 0xee, 0x77, 0x2e, 0x74, 0xde, 0x78, 0x02, 0x40, 0x02, 0x40,
+                                       0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00};
+const unsigned char suv_right_bits[] = {0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0xf0, 0x0f, 0xee, 0x77, 0xee,
+                                    0x77, 0xee, 0x77, 0x2e, 0x74, 0x1e, 0x7b, 0x02, 0x40, 0x02, 0x40,
+                                    0x3c, 0x3c, 0x42, 0x42, 0xda, 0x5b, 0x18, 0x18, 0x00, 0x00};
+
+#define truck_width 32
+#define truck_height 16
+const unsigned char truck_left_bits[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xff, 0x7f, 0xe0,
+                                         0xff, 0xff, 0x7f, 0xf0, 0xff, 0xff, 0x7f, 0xee, 0xff, 0xff, 0x7f, 0xee, 0x03,
+                                         0x00, 0x60, 0x2e, 0x02, 0x00, 0x40, 0xae, 0x02, 0x00, 0x40, 0xbe, 0x02, 0x00,
+                                         0x40, 0x02, 0x02, 0x00, 0x40, 0x3c, 0x02, 0xbc, 0x47, 0x42, 0x02, 0x42, 0x48,
+                                         0xda, 0xff, 0x5b, 0x7b, 0x18, 0x38, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00};
+const unsigned char truck_right_bits[] = {0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x00, 0xfe, 0xff, 0xff, 0x00, 0xfe,
+                                          0xff, 0xff, 0x07, 0xfe, 0xff, 0xff, 0x0f, 0xfe, 0xff, 0xff, 0x77, 0x06, 0x00,
+                                          0xc0, 0x77, 0x02, 0x00, 0x40, 0x74, 0x02, 0x00, 0x40, 0x75, 0x02, 0x00, 0x40,
+                                          0x7d, 0x02, 0x00, 0x40, 0x40, 0xe2, 0x3d, 0x40, 0x3c, 0x12, 0x42, 0x40, 0x42,
+                                          0xde, 0xda, 0xff, 0x5b, 0xc0, 0x18, 0x1c, 0x18, 0x00, 0x00, 0x00, 0x00};

firmware/components/insa/include/ui/ClockScreenSaver.h

@@ -0,0 +1,69 @@
+/**
+ * @file ClockScreenSaver.h
+ * @brief Animated clock screensaver implementation with bouncing time display
+ * @details This header defines the ClockScreenSaver class which provides an animated
+ *          clock screensaver that shows the system time bouncing around the screen.
+ *          The screensaver prevents screen burn-in while displaying useful information.
+ * @author System Control Team
+ * @date 2025-06-14
+ */
+
+#pragma once
+
+#include "MenuOptions.h"
+#include "common/Widget.h"
+
+/**
+ * @class ClockScreenSaver
+ * @brief Animated clock screensaver widget for system idle periods
+ */
+class ClockScreenSaver final : public Widget
+{
+  public:
+    explicit ClockScreenSaver(menu_options_t *options);
+    void update(uint64_t dt) override;
+    void render() override;
+    void onButtonClicked(ButtonType button) override;
+
+  private:
+    static constexpr int MOVE_INTERVAL = 50;                       // milliseconds between movements
+    static constexpr int X_VELOCITY = 1;                           // horizontal movement speed
+    static constexpr int Y_VELOCITY = 1;                           // vertical movement speed
+    static constexpr int TEXT_PADDING = 0;                         // padding around text for bounds checking
+    static constexpr const uint8_t *FONT = u8g2_font_profont15_tf; // font for time display
+
+    menu_options_t *m_options;
+    uint64_t m_moveTimer;
+
+    // Position and movement
+    int m_posX;
+    int m_posY;
+    int m_velocityX;
+    int m_velocityY;
+
+    // Text dimensions (calculated once)
+    int m_textWidth;
+    int m_textHeight;
+
+    /**
+     * @brief Initialize position and movement
+     */
+    void initPosition();
+
+    /**
+     * @brief Update the text dimensions based on current time
+     */
+    void updateTextDimensions();
+
+    /**
+     * @brief Get the current time as a formatted string
+     * @param buffer Buffer to store the formatted time
+     * @param bufferSize Size of the buffer
+     */
+    void getCurrentTimeString(char *buffer, size_t bufferSize) const;
+
+    /**
+     * @brief Check and handle collision with screen boundaries
+     */
+    void checkBoundaryCollision();
+};

firmware/components/insa/include/ui/ScreenSaver.h

@@ -0,0 +1,142 @@
+/**
+ * @file ScreenSaver.h
+ * @brief Animated screensaver implementation with vehicle effect
+ * @details This header defines the ScreenSaver class which provides an animated
+ *          vehicle screensaver that activates during periods of user inactivity.
+ *          The screensaver displays moving vehicles to prevent screen burn-in while
+ *          providing visual feedback that the system is still active and responsive.
+ * @author System Control Team
+ * @date 2025-06-14
+ */
+
+#pragma once
+
+#include "MenuOptions.h"
+#include "common/Widget.h"
+#include <vector>
+
+/**
+ * @class ScreenSaver
+ * @brief Animated vehicle screensaver widget for system idle periods
+ */
+class ScreenSaver final : public Widget
+{
+  public:
+    explicit ScreenSaver(menu_options_t *options);
+    void update(uint64_t dt) override;
+    void render() override;
+    void onButtonClicked(ButtonType button) override;
+
+  private:
+    /**
+     * @enum VehicleType
+     * @brief Types of available vehicles
+     */
+    enum class VehicleType
+    {
+        CAR,
+        CONVERTABLE,
+        SUV,
+        LORRY,
+        TRUCK
+    };
+
+    /**
+     * @enum Direction
+     * @brief Movement direction for vehicles
+     */
+    enum class Direction
+    {
+        LEFT,
+        RIGHT
+    };
+
+    /**
+     * @struct Vehicle
+     * @brief Individual vehicle object for animation
+     */
+    struct Vehicle
+    {
+        int x;               // X position on screen
+        int y;               // Y position on screen
+        float speed;         // Movement speed
+        VehicleType type;    // Type of vehicle
+        Direction direction; // Movement direction
+        bool active;         // Whether a vehicle is currently active
+    };
+
+    static constexpr int MAX_LEFT_VEHICLES = 2;
+    static constexpr int MAX_RIGHT_VEHICLES = 2;
+    static constexpr int MAX_VEHICLES = MAX_LEFT_VEHICLES + MAX_RIGHT_VEHICLES;
+    static constexpr int VEHICLE_SPAWN_DELAY = 2500; // milliseconds
+    static constexpr float MIN_SPEED = 1.0f;
+    static constexpr float MAX_SPEED = 2.0f;
+    static constexpr int MIN_SAME_DIRECTION_DISTANCE = 48; // 32 + 16 pixels
+    static constexpr int MAX_SAME_DIRECTION_DISTANCE = 64; // 32 + 32 pixels
+
+    menu_options_t *m_options;
+    uint64_t m_animationCounter;
+    uint64_t m_lastSpawnTime;
+
+    std::vector<Vehicle> m_vehicles;
+    int m_leftVehicleCount;
+    int m_rightVehicleCount;
+    int m_sceneOffsetX = 0;
+    int m_sceneOffsetY = 0;
+    uint64_t m_sceneShiftTimer = 0;
+
+    /**
+     * @brief Initialize vehicle system
+     */
+    void initVehicles();
+
+    /**
+     * @brief Spawn a new vehicle if conditions are met
+     */
+    void trySpawnVehicle();
+
+    /**
+     * @brief Get a random vehicle type
+     * @return Random VehicleType
+     */
+    static VehicleType getRandomVehicleType();
+
+    /**
+     * @brief Get a random direction with constraint checking
+     * @return Direction for new vehicle
+     */
+    static Direction getRandomDirection();
+
+    /**
+     * @brief Draw a vehicle at a specified position
+     * @param vehicle Vehicle to draw
+     */
+    void drawVehicle(const Vehicle &vehicle) const;
+
+    /**
+     * @brief Draw a bitmap with transparency (black pixels are transparent)
+     * @param x X position
+     * @param y Y position
+     * @param width Bitmap width
+     * @param height Bitmap height
+     * @param bitmap Bitmap data
+     */
+    void drawTransparentBitmap(int x, int y, int width, int height, const unsigned char *bitmap) const;
+
+    /**
+     * @brief Get vehicle bitmap data
+     * @param type Vehicle type
+     * @param direction Movement direction
+     * @param width Output parameter for bitmap width
+     * @param height Output parameter for bitmap height
+     * @return Pointer to bitmap data
+     */
+    static const unsigned char *getVehicleBitmap(VehicleType type, Direction direction, int &width, int &height);
+
+    /**
+     * @brief Check if there's enough distance to spawn a vehicle in a specific direction
+     * @param direction Direction to check
+     * @return true if spawning is allowed
+     */
+    bool canSpawnInDirection(Direction direction) const;
+};

firmware/components/insa/src/common/InactivityTracker.cpp

@@ -1,6 +1,6 @@
 #include "common/InactivityTracker.h"
 
-InactivityTracker::InactivityTracker(uint64_t timeoutMs, std::function<void()> onTimeout)
+InactivityTracker::InactivityTracker(const uint64_t timeoutMs, const std::function<void()> &onTimeout)
     : m_timeoutMs(timeoutMs), m_elapsedTime(0), m_enabled(true), m_onTimeout(onTimeout)
 {
 }

firmware/components/insa/src/ui/ClockScreenSaver.cpp

@@ -0,0 +1,122 @@
+#include "ui/ClockScreenSaver.h"
+#include <cstring>
+#include <ctime>
+
+ClockScreenSaver::ClockScreenSaver(menu_options_t *options)
+    : Widget(options->u8g2), m_options(options), m_moveTimer(0), m_posX(0), m_posY(0), m_velocityX(X_VELOCITY),
+      m_velocityY(Y_VELOCITY), m_textWidth(0), m_textHeight(0)
+{
+    initPosition();
+}
+
+void ClockScreenSaver::initPosition()
+{
+    // Start in the center of the screen
+    updateTextDimensions();
+    m_posX = (u8g2->width - m_textWidth) / 2;
+    m_posY = (u8g2->height - m_textHeight) / 2;
+
+    // Set initial velocity
+    m_velocityX = X_VELOCITY;
+    m_velocityY = Y_VELOCITY;
+}
+
+void ClockScreenSaver::updateTextDimensions()
+{
+    char timeBuffer[32];
+    getCurrentTimeString(timeBuffer, sizeof(timeBuffer));
+
+    // Set font (use a large font for better visibility)
+    u8g2_SetFont(u8g2, FONT);
+
+    // Calculate text dimensions
+    m_textWidth = u8g2_GetStrWidth(u8g2, timeBuffer);
+    m_textHeight = u8g2_GetAscent(u8g2) - u8g2_GetDescent(u8g2);
+}
+
+void ClockScreenSaver::getCurrentTimeString(char *buffer, size_t bufferSize) const
+{
+    time_t rawtime;
+    struct tm *timeinfo;
+
+    time(&rawtime);
+    timeinfo = localtime(&rawtime);
+
+    // Format time as HH:MM:SS
+    strftime(buffer, bufferSize, "%H:%M:%S", timeinfo);
+}
+
+void ClockScreenSaver::update(const uint64_t dt)
+{
+    m_moveTimer += dt;
+
+    // Move the clock position at regular intervals
+    if (m_moveTimer > MOVE_INTERVAL)
+    {
+        m_moveTimer = 0;
+
+        // Update text dimensions (in case time format changes)
+        updateTextDimensions();
+
+        // Update position
+        m_posX += m_velocityX;
+        m_posY += m_velocityY;
+
+        // Check for collisions with screen boundaries
+        checkBoundaryCollision();
+    }
+}
+
+void ClockScreenSaver::checkBoundaryCollision()
+{
+    // Check horizontal boundaries
+    if (m_posX <= TEXT_PADDING)
+    {
+        m_posX = TEXT_PADDING;
+        m_velocityX = X_VELOCITY; // Bounce right
+    }
+    else if (m_posX + m_textWidth >= u8g2->width - TEXT_PADDING)
+    {
+        m_posX = u8g2->width - m_textWidth - TEXT_PADDING;
+        m_velocityX = -X_VELOCITY; // Bounce left
+    }
+
+    // Check vertical boundaries
+    if (m_posY <= TEXT_PADDING + m_textHeight)
+    {
+        m_posY = TEXT_PADDING + m_textHeight;
+        m_velocityY = Y_VELOCITY; // Bounce down
+    }
+    else if (m_posY >= u8g2->height - TEXT_PADDING)
+    {
+        m_posY = u8g2->height - TEXT_PADDING;
+        m_velocityY = -Y_VELOCITY; // Bounce up
+    }
+}
+
+void ClockScreenSaver::render()
+{
+    // Clear screen with a black background
+    u8g2_SetDrawColor(u8g2, 0);
+    u8g2_DrawBox(u8g2, 0, 0, u8g2->width, u8g2->height);
+    u8g2_SetDrawColor(u8g2, 1);
+
+    // Get current time
+    char timeBuffer[32];
+    getCurrentTimeString(timeBuffer, sizeof(timeBuffer));
+
+    // Set font
+    u8g2_SetFont(u8g2, FONT);
+
+    // Draw the time at current position
+    u8g2_DrawStr(u8g2, m_posX, m_posY, timeBuffer);
+}
+
+void ClockScreenSaver::onButtonClicked(ButtonType button)
+{
+    // Exit screensaver on any button press
+    if (m_options && m_options->popScreen)
+    {
+        m_options->popScreen();
+    }
+}

firmware/components/insa/src/ui/LightMenu.cpp

@@ -1,5 +1,6 @@
 #include "ui/LightMenu.h"
 
+#include "led_manager.h"
 #include "ui/LightSettingsMenu.h"
 
 /**
@@ -8,16 +9,16 @@
  */
 namespace LightMenuItem
 {
-constexpr uint8_t ACTIVATE = 0; ///< ID for the light activation toggle
-constexpr uint8_t MODE = 1; ///< ID for the light mode selection
-constexpr uint8_t LED_SETTINGS = 2; ///< ID for the LED settings menu item
+constexpr auto ACTIVATE = 0;     ///< ID for the light activation toggle
+constexpr auto MODE = 1;         ///< ID for the light mode selection
+constexpr auto LED_SETTINGS = 2; ///< ID for the LED settings menu item
 } // namespace LightMenuItem
 
 namespace LightMenuOptions
 {
-constexpr std::string LIGHT_ACTIVE = "light_active";
-constexpr std::string LIGHT_MODE = "light_mode";
-}
+constexpr auto LIGHT_ACTIVE = "light_active";
+constexpr auto LIGHT_MODE = "light_mode";
+} // namespace LightMenuOptions
 
 LightMenu::LightMenu(menu_options_t *options) : Menu(options), m_options(options)
 {
@@ -31,7 +32,7 @@ LightMenu::LightMenu(menu_options_t *options) : Menu(options), m_options(options
 
     // Create mode selection options (Day/Night modes)
     std::vector<std::string> values;
-    values.emplace_back("Tag"); // Day mode
+    values.emplace_back("Tag");   // Day mode
     values.emplace_back("Nacht"); // Night mode
     int mode_value = 0;
     if (m_options && m_options->persistenceManager)
@@ -56,9 +57,19 @@ void LightMenu::onButtonPressed(const MenuItem &menuItem, const ButtonType butto
         if (button == ButtonType::SELECT)
         {
             toggle(menuItem);
+            const auto value = getItem(menuItem.getId()).getValue() == "1";
+            if (value)
+            {
+                led_event_data_t payload = {.value = 42};
+                send_event(EVENT_LED_ON, &payload);
+            }
+            else
+            {
+                led_event_data_t payload = {.value = 0};
+                send_event(EVENT_LED_OFF, &payload);
+            }
             if (m_options && m_options->persistenceManager)
             {
-                const auto value = getItem(menuItem.getId()).getValue() == "1";
                 m_options->persistenceManager->SetValue(LightMenuOptions::LIGHT_ACTIVE, value);
                 m_options->persistenceManager->Save();
             }
@@ -71,9 +82,12 @@ void LightMenu::onButtonPressed(const MenuItem &menuItem, const ButtonType butto
         const auto item = switchValue(menuItem, button);
         if (button == ButtonType::LEFT || button == ButtonType::RIGHT)
         {
+            const auto value = getItem(item.getId()).getIndex();
+            led_event_data_t payload = {.value = value};
+            send_event(EVENT_LED_DAY + value, &payload);
+
             if (m_options && m_options->persistenceManager)
             {
-                const auto value = getItem(item.getId()).getIndex();
                 m_options->persistenceManager->SetValue(LightMenuOptions::LIGHT_MODE, value);
                 m_options->persistenceManager->Save();
             }

firmware/components/insa/src/ui/ScreenSaver.cpp

@@ -0,0 +1,329 @@
+#include "ui/ScreenSaver.h"
+#include "data/roads.h"
+#include "data/vehicles.h"
+#include <cstdlib>
+
+ScreenSaver::ScreenSaver(menu_options_t *options)
+    : Widget(options->u8g2), m_options(options), m_animationCounter(0), m_lastSpawnTime(0), m_leftVehicleCount(0),
+      m_rightVehicleCount(0)
+{
+    initVehicles();
+}
+
+void ScreenSaver::initVehicles()
+{
+    m_vehicles.resize(MAX_VEHICLES);
+
+    for (auto &vehicle : m_vehicles)
+    {
+        vehicle.active = false;
+    }
+}
+
+void ScreenSaver::update(const uint64_t dt)
+{
+    m_animationCounter += dt;
+    m_lastSpawnTime += dt;
+    m_sceneShiftTimer += dt;
+
+    // Shift entire scene every 30 seconds
+    if (m_sceneShiftTimer > 30000)
+    {
+        m_sceneOffsetX = (random() % 7) - 3; // -3 to +3 pixels
+        m_sceneOffsetY = (random() % 7) - 3; // -3 to +3 pixels
+        m_sceneShiftTimer = 0;
+    }
+
+    // Try to spawn a new vehicle every few seconds
+    if (m_lastSpawnTime > VEHICLE_SPAWN_DELAY)
+    {
+        trySpawnVehicle();
+        m_lastSpawnTime = 0;
+    }
+
+    // Update vehicle positions
+    if (m_animationCounter > 16) // ~60 FPS
+    {
+        m_animationCounter = 0;
+
+        for (auto &vehicle : m_vehicles)
+        {
+            if (!vehicle.active)
+                continue;
+
+            // Move vehicle
+            if (vehicle.direction == Direction::LEFT)
+            {
+                vehicle.x -= static_cast<int>(vehicle.speed);
+
+                // Remove the vehicle if it goes off-screen
+                if (vehicle.x <= -32) // Allow for largest vehicle width
+                {
+                    vehicle.active = false;
+                    m_leftVehicleCount--;
+                }
+            }
+            else // Direction::RIGHT
+            {
+                vehicle.x += static_cast<int>(vehicle.speed);
+
+                // Remove the vehicle if it goes off-screen
+                if (vehicle.x >= (u8g2->width + 32)) // Allow for largest vehicle width
+                {
+                    vehicle.active = false;
+                    m_rightVehicleCount--;
+                }
+            }
+        }
+    }
+}
+
+bool ScreenSaver::canSpawnInDirection(Direction direction) const
+{
+    // Minimalen Abstand zwischen 48 und 64 Pixel zufällig wählen
+    int requiredDistance =
+        MIN_SAME_DIRECTION_DISTANCE + (random() % (MAX_SAME_DIRECTION_DISTANCE - MIN_SAME_DIRECTION_DISTANCE + 1));
+
+    for (const auto &vehicle : m_vehicles)
+    {
+        if (!vehicle.active || vehicle.direction != direction)
+            continue;
+
+        // Abstand zum nächsten Fahrzeug in gleicher Richtung prüfen
+        if (direction == Direction::LEFT)
+        {
+            // Fahrzeuge fahren von rechts nach links
+            // Neues Fahrzeug würde bei u8g2->width + 16 starten
+            int newVehicleX = u8g2->width + 16;
+
+            // Prüfen ob genug Abstand zum existierenden Fahrzeug
+            if (newVehicleX - vehicle.x < requiredDistance)
+                return false;
+        }
+        else // Direction::RIGHT
+        {
+            // Fahrzeuge fahren von links nach rechts
+            // Neues Fahrzeug würde bei -32 starten
+            int newVehicleX = -32;
+
+            // Prüfen ob genug Abstand zum existierenden Fahrzeug
+            if (vehicle.x - newVehicleX < requiredDistance)
+                return false;
+        }
+    }
+
+    return true;
+}
+
+void ScreenSaver::trySpawnVehicle()
+{
+    // Check if we can spawn a new vehicle
+    int activeVehicles = 0;
+    int availableSlot = -1;
+
+    for (int i = 0; i < MAX_VEHICLES; i++)
+    {
+        if (m_vehicles[i].active)
+        {
+            activeVehicles++;
+        }
+        else if (availableSlot == -1)
+        {
+            availableSlot = i;
+        }
+    }
+
+    // Don't spawn if we're at max capacity or no slot available
+    if (activeVehicles >= MAX_VEHICLES || availableSlot == -1)
+    {
+        return;
+    }
+
+    Direction direction = getRandomDirection();
+
+    // Check direction constraints
+    if ((direction == Direction::LEFT && m_leftVehicleCount >= MAX_LEFT_VEHICLES) ||
+        (direction == Direction::RIGHT && m_rightVehicleCount >= MAX_RIGHT_VEHICLES))
+    {
+        return;
+    }
+
+    if (!canSpawnInDirection(direction))
+    {
+        return;
+    }
+
+    // Create new vehicle
+    Vehicle &newVehicle = m_vehicles[availableSlot];
+    newVehicle.type = getRandomVehicleType();
+    newVehicle.direction = direction;
+    newVehicle.speed = MIN_SPEED + (static_cast<float>(random()) / RAND_MAX) * (MAX_SPEED - MIN_SPEED);
+
+    // Set Y position based on a direction (simulate opposing traffic lanes)
+    const int halfHeight = u8g2->height / 2;
+    if (direction == Direction::RIGHT)
+    {
+        // Vehicles going LEFT use bottom half of screen
+        newVehicle.y = halfHeight + 8 + (random() % (halfHeight - 24));
+        m_rightVehicleCount++;
+    }
+    else // Direction::RIGHT
+    {
+        // Vehicles going RIGHT use top half of screen
+        newVehicle.y = 8 + (random() % (halfHeight - 24));
+        m_leftVehicleCount++;
+    }
+
+    // Set the starting X position based on the direction
+    if (direction == Direction::LEFT)
+    {
+        // Vehicles going LEFT (from right to left) start from RIGHT side of screen
+        newVehicle.x = u8g2->width + 16;
+    }
+    else // Direction::RIGHT
+    {
+        // Vehicles going RIGHT (from left to right) start from LEFT side of screen
+        newVehicle.x = -32; // Account for the largest vehicle width
+    }
+
+    newVehicle.active = true;
+}
+
+ScreenSaver::VehicleType ScreenSaver::getRandomVehicleType()
+{
+    switch (random() % 5)
+    {
+    case 0:
+        return VehicleType::CAR;
+    case 1:
+        return VehicleType::CONVERTABLE;
+    case 2:
+        return VehicleType::SUV;
+    case 3:
+        return VehicleType::LORRY;
+    case 4:
+        return VehicleType::TRUCK;
+    default:
+        return VehicleType::CAR;
+    }
+}
+
+ScreenSaver::Direction ScreenSaver::getRandomDirection()
+{
+    // Simple 50/50 chance for each direction
+    return (random() % 2 == 0) ? Direction::LEFT : Direction::RIGHT;
+}
+
+void ScreenSaver::render()
+{
+    // Clear screen with a black background
+    u8g2_SetDrawColor(u8g2, 0);
+    u8g2_DrawBox(u8g2, 0, 0, u8g2->width, u8g2->height);
+    u8g2_SetDrawColor(u8g2, 1);
+
+    // Calculate offsets
+    const int roadOffset = (m_animationCounter / 100) % road_horizontal_width;
+
+    // Draw all active vehicles with a scene offset
+    for (const auto &vehicle : m_vehicles)
+    {
+        if (vehicle.active)
+        {
+            Vehicle offsetVehicle = vehicle;
+            offsetVehicle.x += m_sceneOffsetX;
+            offsetVehicle.y += m_sceneOffsetY;
+            drawVehicle(offsetVehicle);
+        }
+    }
+
+    // Draw road with offsets
+    const int y = u8g2->height / 2 - road_horizontal_height / 2 + m_sceneOffsetY;
+    for (int x = -road_horizontal_width + roadOffset + m_sceneOffsetX; x <= u8g2->width; x += road_horizontal_width)
+    {
+        drawTransparentBitmap(x, y, road_horizontal_width, road_horizontal_height, road_horizontal_bits);
+    }
+}
+
+void ScreenSaver::drawVehicle(const Vehicle &vehicle) const
+{
+    int width, height;
+
+    if (const unsigned char *bitmap = getVehicleBitmap(vehicle.type, vehicle.direction, width, height))
+    {
+        drawTransparentBitmap(vehicle.x, vehicle.y, width, height, bitmap);
+        // u8g2_DrawXBM(u8g2, vehicle.x, vehicle.y, width, height, bitmap);
+    }
+}
+
+void ScreenSaver::drawTransparentBitmap(const int x, const int y, const int width, const int height,
+                                        const unsigned char *bitmap) const
+{
+    for (int py = 0; py < height; py++)
+    {
+        for (int px = 0; px < width; px++)
+        {
+            // Calculate byte and a bit of position in bitmap
+            const int byteIndex = (py * ((width + 7) / 8)) + (px / 8);
+
+            // Check if the pixel is set (white)
+            if (const int bitIndex = px % 8; bitmap[byteIndex] & (1 << bitIndex))
+            {
+                // Only draw white pixels, skip black (transparent) pixels
+                const int screenX = x + px;
+
+                // Bounds checking
+                if (const int screenY = y + py;
+                    screenX >= 0 && screenX < u8g2->width && screenY >= 0 && screenY < u8g2->height)
+                {
+                    u8g2_DrawPixel(u8g2, screenX, screenY);
+                }
+            }
+            // Black pixels are simply not drawn (transparent)
+        }
+    }
+}
+
+const unsigned char *ScreenSaver::getVehicleBitmap(const VehicleType type, const Direction direction, int &width,
+                                                   int &height)
+{
+    switch (type)
+    {
+    case VehicleType::CAR:
+        width = car_width;
+        height = car_height;
+        return (direction == Direction::LEFT) ? car_left_bits : car_right_bits;
+
+    case VehicleType::CONVERTABLE:
+        width = convertable_width;
+        height = convertable_height;
+        return (direction == Direction::LEFT) ? convertable_left_bits : convertable_right_bits;
+
+    case VehicleType::SUV:
+        width = suv_width;
+        height = suv_height;
+        return (direction == Direction::LEFT) ? suv_left_bits : suv_right_bits;
+
+    case VehicleType::LORRY:
+        width = lorry_width;
+        height = lorry_height;
+        return (direction == Direction::LEFT) ? lorry_left_bits : lorry_right_bits;
+
+    case VehicleType::TRUCK:
+        width = truck_width;
+        height = truck_height;
+        return (direction == Direction::LEFT) ? truck_left_bits : truck_right_bits;
+
+    default:
+        width = car_width;
+        height = car_height;
+        return car_left_bits;
+    }
+}
+
+void ScreenSaver::onButtonClicked(ButtonType button)
+{
+    if (m_options && m_options->popScreen)
+    {
+        m_options->popScreen();
+    }
+}

firmware/components/led-manager/CMakeLists.txt

@@ -0,0 +1,30 @@
+if (DEFINED ENV{IDF_PATH})
+    idf_component_register(SRCS
+                src/hal_esp32/led_manager.cpp
+                src/hal_esp32/led_status.cpp
+            INCLUDE_DIRS "include"
+            PRIV_REQUIRES
+                u8g2
+                esp_event
+                esp_timer
+                persistence-manager
+    )
+    return()
+endif ()
+
+cmake_minimum_required(VERSION 3.30)
+project(led-manager)
+
+add_library(${PROJECT_NAME} STATIC
+        src/hal_native/led_manager.cpp
+        src/hal_native/Matrix.cpp
+)
+
+include_directories(include)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+        SDL3::SDL3
+        persistence-manager
+)

firmware/components/led-manager/idf_component.yml

@@ -0,0 +1,2 @@
+dependencies:
+  espressif/led_strip: '~3.0.1'

firmware/components/led-manager/include/Matrix.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "SDL3/SDL_render.h"
+
+#include <cstdint>
+
+class Matrix
+{
+  public:
+    explicit Matrix(SDL_WindowID windowId, SDL_Renderer *renderer, uint8_t cols, uint8_t rows);
+
+    [[nodiscard]] SDL_Renderer *renderer() const;
+
+    void Render() const;
+
+    [[nodiscard]] SDL_WindowID windowId() const;
+
+  private:
+    void DrawColoredGrid() const;
+
+    SDL_WindowID m_windowId;
+    SDL_Renderer *m_renderer;
+
+    uint8_t m_cols;
+    uint8_t m_rows;
+
+    static constexpr float cellSize = 50.0f;
+    static constexpr float spacing = 1.0f;
+};

firmware/components/led-manager/include/led_manager.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+
+enum
+{
+    EVENT_LED_ON,
+    EVENT_LED_OFF,
+    EVENT_LED_DAY,
+    EVENT_LED_NIGHT,
+};
+
+typedef struct
+{
+    int value;
+} led_event_data_t;
+
+uint64_t wled_init();
+
+uint64_t register_handler();
+
+uint64_t send_event(uint32_t event, led_event_data_t *payload);

firmware/components/led-manager/include/led_status.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "driver/rmt_tx.h"
+#include <stdint.h>
+
+// Number of LEDs to be controlled
+#define STATUS_LED_COUNT 3
+
+// Possible lighting modes
+typedef enum
+{
+    LED_MODE_OFF,
+    LED_MODE_SOLID,
+    LED_MODE_BLINK
+} led_mode_t;
+
+// Structure for an RGB color
+typedef struct
+{
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+} rgb_t;
+
+// This is the structure you pass from the outside to define a behavior
+typedef struct
+{
+    led_mode_t mode;
+    rgb_t color;
+    uint32_t on_time_ms = 0;  // Only relevant for BLINK
+    uint32_t off_time_ms = 0; // Only relevant for BLINK
+} led_behavior_t;
+
+/**
+ * @brief Initializes the status manager and the LED strip.
+ *
+ * @param gpio_num GPIO where the data line of the LEDs is connected.
+ * @return esp_err_t ESP_OK on success.
+ */
+esp_err_t led_status_init(int gpio_num);
+
+/**
+ * @brief Sets the lighting behavior for a single LED.
+ *
+ * This function is thread-safe.
+ *
+ * @param index Index of the LED (0 to STATUS_LED_COUNT - 1).
+ * @param behavior The structure with the desired behavior.
+ * @return esp_err_t ESP_OK on success, ESP_ERR_INVALID_ARG on invalid index.
+ */
+esp_err_t led_status_set_behavior(uint8_t index, led_behavior_t behavior);

firmware/components/led-manager/src/hal_esp32/led_manager.cpp

@@ -0,0 +1,98 @@
+#include "led_manager.h"
+
+#include "esp_event.h"
+#include "esp_log.h"
+#include "led_strip.h"
+#include "sdkconfig.h"
+
+led_strip_handle_t led_strip;
+
+static const uint32_t value = 5;
+
+ESP_EVENT_DECLARE_BASE(LED_EVENTS_BASE);
+ESP_EVENT_DEFINE_BASE(LED_EVENTS_BASE);
+
+esp_event_loop_handle_t loop_handle;
+
+const char *TAG = "LED";
+
+uint64_t wled_init(void)
+{
+    led_strip_config_t strip_config = {
+        .strip_gpio_num = CONFIG_WLED_DIN_PIN,
+        .max_leds = 64,
+        .led_model = LED_MODEL_WS2812,
+        .color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_GRB,
+        .flags =
+            {
+                .invert_out = false,
+            },
+    };
+
+    led_strip_rmt_config_t rmt_config = {
+        .clk_src = RMT_CLK_SRC_DEFAULT,
+        .resolution_hz = 0,
+        .mem_block_symbols = 0,
+        .flags =
+            {
+                .with_dma = true,
+            },
+    };
+
+    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip));
+
+    for (uint32_t i = 0; i < 3; i++)
+    {
+        led_strip_set_pixel(led_strip, i, 10, 10, 0);
+    }
+    led_strip_refresh(led_strip);
+
+    return ESP_OK;
+}
+
+void event_handler(void *arg, esp_event_base_t base, int32_t id, void *event_data)
+{
+    if (id == EVENT_LED_ON || id == EVENT_LED_OFF)
+    {
+        auto brightness = (id == EVENT_LED_ON) ? value : 0;
+        for (uint32_t i = 0; i < 64; i++)
+        {
+            led_strip_set_pixel(led_strip, i, brightness, brightness, brightness);
+        }
+        led_strip_refresh(led_strip);
+    }
+}
+
+uint64_t register_handler(void)
+{
+    esp_event_loop_args_t loop_args = {
+        .queue_size = 2, .task_name = "led_manager", .task_priority = 5, .task_stack_size = 4096, .task_core_id = 1};
+    esp_event_loop_create(&loop_args, &loop_handle);
+
+    esp_event_handler_register_with(loop_handle, LED_EVENTS_BASE, ESP_EVENT_ANY_ID, event_handler, NULL);
+    return ESP_OK;
+}
+
+uint64_t send_event(uint32_t event, led_event_data_t *payload)
+{
+    if (payload == nullptr)
+    {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_err_t err = esp_event_post_to(loop_handle,              // Event loop handle
+                                      LED_EVENTS_BASE,          // Event base
+                                      event,                    // Event ID (EVENT_LED_ON, EVENT_LED_OFF, etc.)
+                                      payload,                  // Data pointer
+                                      sizeof(led_event_data_t), // Data size
+                                      portMAX_DELAY             // Wait time
+    );
+
+    if (err != ESP_OK)
+    {
+        ESP_LOGE("LED", "Failed to post event: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    return ESP_OK;
+}

firmware/components/led-manager/src/hal_esp32/led_status.cpp

@@ -0,0 +1,145 @@
+#include "led_status.h"
+
+#include "esp_log.h"
+#include "esp_timer.h" // For high-resolution timestamps
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "freertos/task.h"
+#include "led_strip.h"
+
+static const char *TAG = "LED_STATUS";
+
+// Internal control structure for each LED
+typedef struct
+{
+    led_behavior_t behavior;      // The desired behavior (target state)
+    uint64_t last_toggle_time_us; // Timestamp of the last toggle (in microseconds)
+    bool is_on_in_blink;          // Current state in blink mode (actual state)
+} led_control_t;
+
+// --- Module variables ---
+static led_strip_handle_t led_strip;
+static led_control_t led_controls[STATUS_LED_COUNT];
+static SemaphoreHandle_t mutex; // To protect the led_controls array
+
+// The core: The task that controls the LEDs
+static void led_status_task(void *pvParameters)
+{
+    ESP_LOGI(TAG, "Led Status Task started.");
+
+    while (1)
+    {
+        uint64_t now_us = esp_timer_get_time();
+
+        // Take the mutex to safely access the control data
+        if (xSemaphoreTake(mutex, portMAX_DELAY) == pdTRUE)
+        {
+
+            for (int i = 0; i < STATUS_LED_COUNT; i++)
+            {
+                led_control_t *control = &led_controls[i];
+
+                switch (control->behavior.mode)
+                {
+                case LED_MODE_OFF:
+                    led_strip_set_pixel(led_strip, i, 0, 0, 0);
+                    break;
+
+                case LED_MODE_SOLID:
+                    led_strip_set_pixel(led_strip, i, control->behavior.color.r, control->behavior.color.g,
+                                        control->behavior.color.b);
+                    break;
+
+                case LED_MODE_BLINK: {
+                    uint32_t duration_ms =
+                        control->is_on_in_blink ? control->behavior.on_time_ms : control->behavior.off_time_ms;
+                    if ((now_us - control->last_toggle_time_us) / 1000 >= duration_ms)
+                    {
+                        control->is_on_in_blink = !control->is_on_in_blink; // Toggle state
+                        control->last_toggle_time_us = now_us;              // Update timestamp
+                    }
+
+                    if (control->is_on_in_blink)
+                    {
+                        led_strip_set_pixel(led_strip, i, control->behavior.color.r, control->behavior.color.g,
+                                            control->behavior.color.b);
+                    }
+                    else
+                    {
+                        led_strip_set_pixel(led_strip, i, 0, 0, 0);
+                    }
+                }
+                break;
+                }
+            }
+            // Release the mutex
+            xSemaphoreGive(mutex);
+        }
+
+        // Update the physical LED strip with the new values
+        led_strip_refresh(led_strip);
+
+        // Delay task for 20ms before the next iteration
+        vTaskDelay(pdMS_TO_TICKS(20));
+    }
+}
+
+// Initialization function
+esp_err_t led_status_init(int gpio_num)
+{
+    // LED strip configuration (e.g., for WS2812)
+    led_strip_config_t strip_config = {
+        .strip_gpio_num = gpio_num,
+        .max_leds = STATUS_LED_COUNT,
+        .led_model = LED_MODEL_WS2812,
+        .color_component_format = LED_STRIP_COLOR_COMPONENT_FMT_GRBW,
+        .flags =
+            {
+                .invert_out = false,
+            },
+    };
+    led_strip_rmt_config_t rmt_config = {
+        .clk_src = RMT_CLK_SRC_DEFAULT,
+        .resolution_hz = 10 * 1000 * 1000, // 10MHz
+        .mem_block_symbols = 0,
+        .flags =
+            {
+                .with_dma = false,
+            },
+    };
+    ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip));
+    ESP_LOGI(TAG, "LED strip initialized.");
+
+    // Create mutex
+    mutex = xSemaphoreCreateMutex();
+    if (mutex == NULL)
+    {
+        ESP_LOGE(TAG, "Could not create mutex.");
+        return ESP_FAIL;
+    }
+
+    // Start task
+    xTaskCreate(led_status_task, "led_status_task", 2048, NULL, 5, NULL);
+
+    return ESP_OK;
+}
+
+// Function to set the behavior
+esp_err_t led_status_set_behavior(uint8_t index, led_behavior_t behavior)
+{
+    if (index >= STATUS_LED_COUNT)
+    {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (xSemaphoreTake(mutex, portMAX_DELAY) == pdTRUE)
+    {
+        led_controls[index].behavior = behavior;
+        // Reset internal state variables to start the new pattern cleanly
+        led_controls[index].is_on_in_blink = false;
+        led_controls[index].last_toggle_time_us = esp_timer_get_time();
+        xSemaphoreGive(mutex);
+    }
+
+    return ESP_OK;
+}

firmware/components/led-manager/src/hal_native/Matrix.cpp

@@ -0,0 +1,64 @@
+#include "Matrix.h"
+
+#include "SDL3/SDL.h"
+
+Matrix::Matrix(uint32_t windowID, SDL_Renderer *renderer, const uint8_t cols, const uint8_t rows)
+    : m_windowId(windowID), m_renderer(renderer), m_cols(cols), m_rows(rows)
+{
+}
+
+SDL_Renderer *Matrix::renderer() const
+{
+    return m_renderer;
+}
+
+SDL_WindowID Matrix::windowId() const
+{
+    return m_windowId;
+}
+
+void Matrix::DrawColoredGrid() const
+{
+    int i = 0;
+    for (int w = 0; w < m_cols; w++)
+    {
+        const auto phase = w % (2 * m_rows);
+
+        for (int h_raw = 0; h_raw < m_rows; h_raw++)
+        {
+            int h;
+            if (phase < m_rows)
+            {
+                h = h_raw;
+            }
+            else
+            {
+                h = m_rows - 1 - h_raw;
+            }
+
+            constexpr auto rectSize = cellSize - 2.0f * spacing;
+
+            const auto x = static_cast<float>(w) * cellSize + spacing;
+            const auto y = static_cast<float>(h) * cellSize + spacing;
+
+            auto rect = SDL_FRect{x, y, rectSize, rectSize};
+
+            i++;
+            const auto red = static_cast<Uint8>(static_cast<float>(i) * 255.0f);
+            const auto green = static_cast<Uint8>(static_cast<float>(i) * 255.0f);
+            const auto blue = static_cast<Uint8>(static_cast<float>(i) * 255.0f);
+            SDL_SetRenderDrawColor(m_renderer, red, green, blue, 255);
+            SDL_RenderFillRect(m_renderer, &rect);
+        }
+    }
+}
+
+void Matrix::Render() const
+{
+    SDL_SetRenderDrawColor(m_renderer, 0, 0, 0, 255);
+    SDL_RenderClear(m_renderer);
+
+    DrawColoredGrid();
+
+    SDL_RenderPresent(m_renderer);
+}

firmware/components/led-manager/src/hal_native/led_manager.cpp

@@ -0,0 +1,16 @@
+#include "led_manager.h"
+
+uint64_t wled_init(void)
+{
+    return 0;
+}
+
+uint64_t register_handler(void)
+{
+    return 0;
+}
+
+uint64_t send_event(uint32_t event, led_event_data_t *payload)
+{
+    return 0;
+}

firmware/components/led-manager/src/hal_native/led_status.cpp

@@ -0,0 +1,7 @@
+#include "led_status.h"
+
+void led_status_init()
+{
+    // This function is intentionally left empty for the native implementation.
+    // It serves as a placeholder to maintain compatibility with the HAL interface.
+}

firmware/components/persistence-manager/CMakeLists.txt

@@ -0,0 +1,24 @@
+if (DEFINED ENV{IDF_PATH})
+    idf_component_register(SRCS
+            src/hal_esp32/PersistenceManager.cpp
+            INCLUDE_DIRS "include"
+            REQUIRES
+                nvs_flash
+    )
+    return()
+endif ()
+
+cmake_minimum_required(VERSION 3.30)
+project(persistence-manager)
+
+add_library(${PROJECT_NAME} STATIC
+        src/hal_native/PersistenceManager.cpp
+)
+
+include_directories(include)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+        SDL3::SDL3
+)

firmware/components/persistence-manager/include/IPersistenceManager.h

@@ -35,49 +35,21 @@ public:
      * @brief Template method for type-safe retrieval of values
      * @tparam T The type of value to retrieve
      * @param key The key to look up
-     * @param defaultValue The default value to return if key is not found
-     * @return The stored value or default value if key doesn't exist
+     * @param defaultValue The default value to return if the key is not found
+     * @return The stored value or default value if the key doesn't exist
      */
     template<typename T>
-    T GetValue(const std::string& key, const T& defaultValue = T{}) const {
+    [[nodiscard]] T GetValue(const std::string& key, const T& defaultValue = T{}) const {
         return GetValueImpl<T>(key, defaultValue);
     }
 
-    /**
-     * @brief Convenience methods for setting specific types
-     */
-    void SetBool(const std::string& key, bool value) { SetValue(key, value); }
-    void SetInt(const std::string& key, int value) { SetValue(key, value); }
-    void SetFloat(const std::string& key, float value) { SetValue(key, value); }
-    void SetDouble(const std::string& key, double value) { SetValue(key, value); }
-    void SetString(const std::string& key, const std::string& value) { SetValue(key, value); }
-
-    /**
-     * @brief Convenience methods for getting specific types with default values
-     */
-    bool GetBool(const std::string& key, bool defaultValue = false) const { 
-        return GetValue(key, defaultValue); 
-    }
-    int GetInt(const std::string& key, int defaultValue = 0) const { 
-        return GetValue(key, defaultValue); 
-    }
-    float GetFloat(const std::string& key, float defaultValue = 0.0f) const { 
-        return GetValue(key, defaultValue); 
-    }
-    double GetDouble(const std::string& key, double defaultValue = 0.0) const { 
-        return GetValue(key, defaultValue); 
-    }
-    std::string GetString(const std::string& key, const std::string& defaultValue = "") const { 
-        return GetValue(key, defaultValue); 
-    }
-
     /**
      * @brief Utility methods for key management
      */
-    virtual bool HasKey(const std::string& key) const = 0; ///< Check if a key exists
+    [[nodiscard]] virtual bool HasKey(const std::string& key) const = 0; ///< Check if a key exists
     virtual void RemoveKey(const std::string& key) = 0; ///< Remove a key-value pair
     virtual void Clear() = 0; ///< Clear all stored data
-    virtual size_t GetKeyCount() const = 0; ///< Get the number of stored keys
+    [[nodiscard]] virtual size_t GetKeyCount() const = 0; ///< Get the number of stored keys
 
     /**
      * @brief Persistence operations
@@ -96,11 +68,11 @@ protected:
     virtual void SetValueImpl(const std::string& key, double value) = 0;
     virtual void SetValueImpl(const std::string& key, const std::string& value) = 0;
 
-    virtual bool GetValueImpl(const std::string& key, bool defaultValue) const = 0;
-    virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
-    virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
-    virtual double GetValueImpl(const std::string& key, double defaultValue) const = 0;
-    virtual std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const = 0;
+    [[nodiscard]] virtual bool GetValueImpl(const std::string& key, bool defaultValue) const = 0;
+    [[nodiscard]] virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
+    [[nodiscard]] virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
+    [[nodiscard]] virtual double GetValueImpl(const std::string& key, double defaultValue) const = 0;
+    [[nodiscard]] virtual std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const = 0;
 
 private:
     /**
@@ -111,18 +83,18 @@ private:
      * @return The retrieved value or default if not found
      */
     template<typename T>
-    T GetValueImpl(const std::string& key, const T& defaultValue) const
+    [[nodiscard]] T GetValueImpl(const std::string& key, const T& defaultValue) const
     {
         if constexpr (std::is_same_v<T, bool>) {
-            return GetValueImpl(key, defaultValue);
+            return GetValueImpl(key, static_cast<bool>(defaultValue));
         } else if constexpr (std::is_same_v<T, int>) {
-            return GetValueImpl(key, defaultValue);
+            return GetValueImpl(key, static_cast<int>(defaultValue));
         } else if constexpr (std::is_same_v<T, float>) {
-            return GetValueImpl(key, defaultValue);
+            return GetValueImpl(key, static_cast<float>(defaultValue));
         } else if constexpr (std::is_same_v<T, double>) {
-            return GetValueImpl(key, defaultValue);
+            return GetValueImpl(key, static_cast<double>(defaultValue));
         } else if constexpr (std::is_same_v<T, std::string>) {
-            return GetValueImpl(key, defaultValue);
+            return GetValueImpl(key, static_cast<const std::string&>(defaultValue));
         } else {
             static_assert(std::is_same_v<T, bool> || 
                          std::is_same_v<T, int> || 
@@ -130,7 +102,7 @@ private:
                          std::is_same_v<T, double> || 
                          std::is_same_v<T, std::string>,
                          "Unsupported type for IPersistenceManager");
-            return defaultValue; // This line will never be reached, but satisfies compiler
+            return defaultValue; // This line will never be reached, but satisfies the compiler
         }
     }
 };

firmware/components/persistence-manager/include/hal_esp32/PersistenceManager.h

@@ -14,7 +14,7 @@
  *          in flash memory, providing a platform-optimized solution for
  *          embedded systems.
  */
-class PersistenceManager : public IPersistenceManager
+class PersistenceManager final : public IPersistenceManager
 {
   private:
     nvs_handle_t nvs_handle_;
@@ -25,7 +25,6 @@ class PersistenceManager : public IPersistenceManager
     explicit PersistenceManager(const std::string &nvs_namespace = "config");
     ~PersistenceManager() override;
 
-    // IPersistenceManager implementation
     bool HasKey(const std::string &key) const override;
     void RemoveKey(const std::string &key) override;
     void Clear() override;
@@ -34,7 +33,6 @@ class PersistenceManager : public IPersistenceManager
     bool Save() override;
     bool Load() override;
 
-    // ESP32-specific methods
     bool Initialize();
     void Deinitialize();
     bool IsInitialized() const
@@ -43,7 +41,6 @@ class PersistenceManager : public IPersistenceManager
     }
 
   protected:
-    // Template-spezifische Implementierungen
     void SetValueImpl(const std::string &key, bool value) override;
     void SetValueImpl(const std::string &key, int value) override;
     void SetValueImpl(const std::string &key, float value) override;

firmware/components/persistence-manager/include/hal_native/PersistenceManager.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "common/IPersistenceManager.h"
+#include "../IPersistenceManager.h"
 #include <SDL3/SDL.h>
 #include <unordered_map>
 #include <variant>
@@ -16,42 +16,38 @@ public:
     >;
 
 private:
-    std::unordered_map<std::string, ValueType> data_;
-    std::string filename_;
+    std::unordered_map<std::string, ValueType> m_data;
+    std::string m_filename;
 
 public:
     explicit PersistenceManager(std::string  filename = "settings.dat");
     ~PersistenceManager() override;
 
-    // IPersistenceManager implementation
-    bool HasKey(const std::string& key) const override;
+    [[nodiscard]] bool HasKey(const std::string& key) const override;
     void RemoveKey(const std::string& key) override;
     void Clear() override;
-    size_t GetKeyCount() const override { return data_.size(); }
+    [[nodiscard]] size_t GetKeyCount() const override { return m_data.size(); }
 
     bool Save() override;
     bool Load() override;
 
-    // Erweiterte SDL3-spezifische Methoden
     bool SaveToFile(const std::string& filename);
     bool LoadFromFile(const std::string& filename);
 
 protected:
-    // Template-spezifische Implementierungen
     void SetValueImpl(const std::string& key, bool value) override;
     void SetValueImpl(const std::string& key, int value) override;
     void SetValueImpl(const std::string& key, float value) override;
     void SetValueImpl(const std::string& key, double value) override;
     void SetValueImpl(const std::string& key, const std::string& value) override;
 
-    bool GetValueImpl(const std::string& key, bool defaultValue) const override;
-    int GetValueImpl(const std::string& key, int defaultValue) const override;
-    float GetValueImpl(const std::string& key, float defaultValue) const override;
-    double GetValueImpl(const std::string& key, double defaultValue) const override;
-    std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const override;
+    [[nodiscard]] bool GetValueImpl(const std::string& key, bool defaultValue) const override;
+    [[nodiscard]] int GetValueImpl(const std::string& key, int defaultValue) const override;
+    [[nodiscard]] float GetValueImpl(const std::string& key, float defaultValue) const override;
+    [[nodiscard]] double GetValueImpl(const std::string& key, double defaultValue) const override;
+    [[nodiscard]] std::string GetValueImpl(const std::string& key, const std::string& defaultValue) const override;
 
 private:
-    // Interne Hilfsmethoden für Serialisierung
     static bool WriteValueToStream(SDL_IOStream* stream, const ValueType& value) ;
     static bool ReadValueFromStream(SDL_IOStream* stream, ValueType& value) ;
 

firmware/components/persistence-manager/src/hal_esp32/PersistenceManager.cpp

@@ -1,5 +1,4 @@
-#ifdef ESP_PLATFORM
-#include "common/PersistenceManager.h"
+#include "hal_esp32/PersistenceManager.h"
 #include <cstring>
 #include <esp_log.h>
 
@@ -9,6 +8,7 @@ PersistenceManager::PersistenceManager(const std::string &nvs_namespace)
     : namespace_(nvs_namespace), initialized_(false)
 {
     Initialize();
+    Load();
 }
 
 PersistenceManager::~PersistenceManager()
@@ -291,5 +291,3 @@ std::string PersistenceManager::GetValueImpl(const std::string &key, const std::
 
     return value;
 }
-
-#endif // ESP32

firmware/components/persistence-manager/src/hal_native/PersistenceManager.cpp

@@ -0,0 +1,338 @@
+#include "hal_native/PersistenceManager.h"
+#include <SDL3/SDL.h>
+
+#include <utility>
+
+PersistenceManager::PersistenceManager(std::string filename) : m_filename(std::move(filename))
+{
+    if (!SDL_WasInit(SDL_INIT_EVENTS))
+    {
+        SDL_Init(SDL_INIT_EVENTS);
+    }
+
+    Load();
+}
+
+PersistenceManager::~PersistenceManager()
+{
+    Save();
+}
+
+bool PersistenceManager::HasKey(const std::string &key) const
+{
+    return m_data.contains(key);
+}
+
+void PersistenceManager::RemoveKey(const std::string &key)
+{
+    m_data.erase(key);
+}
+
+void PersistenceManager::Clear()
+{
+    m_data.clear();
+}
+
+bool PersistenceManager::Save()
+{
+    return SaveToFile(m_filename);
+}
+
+bool PersistenceManager::Load()
+{
+    return LoadFromFile(m_filename);
+}
+
+bool PersistenceManager::SaveToFile(const std::string &filename)
+{
+    SDL_IOStream *stream = SDL_IOFromFile(filename.c_str(), "wb");
+    if (!stream)
+    {
+        SDL_Log("Error opening file for writing: %s", SDL_GetError());
+        return false;
+    }
+
+    const size_t count = m_data.size();
+    if (SDL_WriteIO(stream, &count, sizeof(count)) != sizeof(count))
+    {
+        SDL_Log("Error writing count: %s", SDL_GetError());
+        SDL_CloseIO(stream);
+        return false;
+    }
+
+    for (const auto &[key, value] : m_data)
+    {
+        size_t keyLength = key.length();
+        if (SDL_WriteIO(stream, &keyLength, sizeof(keyLength)) != sizeof(keyLength))
+        {
+            SDL_Log("Error writing key length: %s", SDL_GetError());
+            SDL_CloseIO(stream);
+            return false;
+        }
+
+        if (SDL_WriteIO(stream, key.c_str(), keyLength) != keyLength)
+        {
+            SDL_Log("Error writing key: %s", SDL_GetError());
+            SDL_CloseIO(stream);
+            return false;
+        }
+
+        if (!WriteValueToStream(stream, value))
+        {
+            SDL_CloseIO(stream);
+            return false;
+        }
+    }
+
+    SDL_CloseIO(stream);
+    return true;
+}
+
+bool PersistenceManager::LoadFromFile(const std::string &filename)
+{
+    SDL_IOStream *stream = SDL_IOFromFile(filename.c_str(), "rb");
+    if (!stream)
+    {
+        SDL_Log("File not found or error opening: %s", SDL_GetError());
+        return false;
+    }
+
+    m_data.clear();
+
+    size_t count;
+    if (SDL_ReadIO(stream, &count, sizeof(count)) != sizeof(count))
+    {
+        SDL_Log("Error reading count: %s", SDL_GetError());
+        SDL_CloseIO(stream);
+        return false;
+    }
+
+    for (size_t i = 0; i < count; ++i)
+    {
+        size_t keyLength;
+        if (SDL_ReadIO(stream, &keyLength, sizeof(keyLength)) != sizeof(keyLength))
+        {
+            SDL_Log("Error reading key length: %s", SDL_GetError());
+            SDL_CloseIO(stream);
+            return false;
+        }
+
+        std::string key(keyLength, '\0');
+        if (SDL_ReadIO(stream, key.data(), keyLength) != keyLength)
+        {
+            SDL_Log("Error reading key: %s", SDL_GetError());
+            SDL_CloseIO(stream);
+            return false;
+        }
+
+        ValueType value;
+        if (!ReadValueFromStream(stream, value))
+        {
+            SDL_CloseIO(stream);
+            return false;
+        }
+
+        m_data[key] = value;
+    }
+
+    SDL_CloseIO(stream);
+    return true;
+}
+
+void PersistenceManager::SetValueImpl(const std::string &key, bool value)
+{
+    m_data[key] = value;
+}
+
+void PersistenceManager::SetValueImpl(const std::string &key, int value)
+{
+    m_data[key] = value;
+}
+
+void PersistenceManager::SetValueImpl(const std::string &key, float value)
+{
+    m_data[key] = value;
+}
+
+void PersistenceManager::SetValueImpl(const std::string &key, double value)
+{
+    m_data[key] = value;
+}
+
+void PersistenceManager::SetValueImpl(const std::string &key, const std::string &value)
+{
+    m_data[key] = value;
+}
+
+bool PersistenceManager::GetValueImpl(const std::string &key, bool defaultValue) const
+{
+    if (const auto it = m_data.find(key); it != m_data.end() && std::holds_alternative<bool>(it->second))
+    {
+        return std::get<bool>(it->second);
+    }
+    return defaultValue;
+}
+
+int PersistenceManager::GetValueImpl(const std::string &key, int defaultValue) const
+{
+    if (const auto it = m_data.find(key); it != m_data.end() && std::holds_alternative<int>(it->second))
+    {
+        return std::get<int>(it->second);
+    }
+    return defaultValue;
+}
+
+float PersistenceManager::GetValueImpl(const std::string &key, float defaultValue) const
+{
+    if (const auto it = m_data.find(key); it != m_data.end() && std::holds_alternative<float>(it->second))
+    {
+        return std::get<float>(it->second);
+    }
+    return defaultValue;
+}
+
+double PersistenceManager::GetValueImpl(const std::string &key, double defaultValue) const
+{
+    if (const auto it = m_data.find(key); it != m_data.end() && std::holds_alternative<double>(it->second))
+    {
+        return std::get<double>(it->second);
+    }
+    return defaultValue;
+}
+
+std::string PersistenceManager::GetValueImpl(const std::string &key, const std::string &defaultValue) const
+{
+    if (const auto it = m_data.find(key); it != m_data.end() && std::holds_alternative<std::string>(it->second))
+    {
+        return std::get<std::string>(it->second);
+    }
+    return defaultValue;
+}
+
+bool PersistenceManager::WriteValueToStream(SDL_IOStream *stream, const ValueType &value)
+{
+    const TypeId typeId = GetTypeId(value);
+
+    if (SDL_WriteIO(stream, &typeId, sizeof(typeId)) != sizeof(typeId))
+    {
+        SDL_Log("Error writing type ID: %s", SDL_GetError());
+        return false;
+    }
+
+    switch (typeId)
+    {
+    case TypeId::BOOL: {
+        const bool val = std::get<bool>(value);
+        return SDL_WriteIO(stream, &val, sizeof(val)) == sizeof(val);
+    }
+    case TypeId::INT: {
+        const int val = std::get<int>(value);
+        return SDL_WriteIO(stream, &val, sizeof(val)) == sizeof(val);
+    }
+    case TypeId::FLOAT: {
+        const float val = std::get<float>(value);
+        return SDL_WriteIO(stream, &val, sizeof(val)) == sizeof(val);
+    }
+    case TypeId::DOUBLE: {
+        const double val = std::get<double>(value);
+        return SDL_WriteIO(stream, &val, sizeof(val)) == sizeof(val);
+    }
+    case TypeId::STRING: {
+        const auto &str = std::get<std::string>(value);
+        const size_t length = str.length();
+
+        if (SDL_WriteIO(stream, &length, sizeof(length)) != sizeof(length))
+        {
+            return false;
+        }
+
+        return SDL_WriteIO(stream, str.c_str(), length) == length;
+    }
+    }
+    return false;
+}
+
+bool PersistenceManager::ReadValueFromStream(SDL_IOStream *stream, ValueType &value)
+{
+    TypeId typeId;
+
+    if (SDL_ReadIO(stream, &typeId, sizeof(typeId)) != sizeof(typeId))
+    {
+        SDL_Log("Error reading type ID: %s", SDL_GetError());
+        return false;
+    }
+
+    switch (typeId)
+    {
+    case TypeId::BOOL: {
+        bool val;
+        if (SDL_ReadIO(stream, &val, sizeof(val)) == sizeof(val))
+        {
+            value = val;
+            return true;
+        }
+        break;
+    }
+    case TypeId::INT: {
+        int val;
+        if (SDL_ReadIO(stream, &val, sizeof(val)) == sizeof(val))
+        {
+            value = val;
+            return true;
+        }
+        break;
+    }
+    case TypeId::FLOAT: {
+        float val;
+        if (SDL_ReadIO(stream, &val, sizeof(val)) == sizeof(val))
+        {
+            value = val;
+            return true;
+        }
+        break;
+    }
+    case TypeId::DOUBLE: {
+        double val;
+        if (SDL_ReadIO(stream, &val, sizeof(val)) == sizeof(val))
+        {
+            value = val;
+            return true;
+        }
+        break;
+    }
+    case TypeId::STRING: {
+        size_t length;
+        if (SDL_ReadIO(stream, &length, sizeof(length)) != sizeof(length))
+        {
+            return false;
+        }
+
+        std::string str(length, '\0');
+        if (SDL_ReadIO(stream, str.data(), length) == length)
+        {
+            value = str;
+            return true;
+        }
+        break;
+    }
+    }
+
+    SDL_Log("Error reading value: %s", SDL_GetError());
+    return false;
+}
+
+PersistenceManager::TypeId PersistenceManager::GetTypeId(const ValueType &value)
+{
+    if (std::holds_alternative<bool>(value))
+        return TypeId::BOOL;
+    if (std::holds_alternative<int>(value))
+        return TypeId::INT;
+    if (std::holds_alternative<float>(value))
+        return TypeId::FLOAT;
+    if (std::holds_alternative<double>(value))
+        return TypeId::DOUBLE;
+    if (std::holds_alternative<std::string>(value))
+        return TypeId::STRING;
+
+    return TypeId::BOOL;
+}

firmware/main/CMakeLists.txt

@@ -0,0 +1,15 @@
+idf_component_register(SRCS 
+        main.cpp
+        app_task.cpp
+        button_handling.c
+        hal/u8g2_esp32_hal.c
+    INCLUDE_DIRS "."
+    PRIV_REQUIRES
+        insa
+        led-manager
+        persistence-manager
+        u8g2
+        driver
+        esp_timer
+        esp_event
+)

firmware/main/Kconfig.projbuild

@@ -0,0 +1,14 @@
+menu "System Control"
+    config WLED_DIN_PIN
+        int "WLED Data In Pin"
+        default 14
+        help
+            The number of the WLED data in pin.
+
+    config STATUS_WLED_PIN
+        int "Status WLED Pin"
+        default 2
+        help
+            The number of the status WLED pin.
+
+endmenu

firmware/main/app_task.cpp

@@ -7,7 +7,8 @@
 
 #include "button_handling.h"
 #include "common/InactivityTracker.h"
-#include "common/PersistenceManager.h"
+#include "hal_esp32/PersistenceManager.h"
+#include "ui/ClockScreenSaver.h"
 #include "ui/ScreenSaver.h"
 #include "ui/SplashScreen.h"
 
@@ -101,10 +102,9 @@ static void init_ui(void)
         .onButtonClicked = nullptr,
         .persistenceManager = std::make_shared<PersistenceManager>(),
     };
-    options.persistenceManager->Load();
     m_widget = std::make_shared<SplashScreen>(&options);
     m_inactivityTracker = std::make_unique<InactivityTracker>(60000, []() {
-        auto screensaver = std::make_shared<ScreenSaver>(&options);
+        auto screensaver = std::make_shared<ClockScreenSaver>(&options);
         options.pushScreen(screensaver);
     });
 }

firmware/main/button_handling.c

@@ -0,0 +1,88 @@
+#include "button_handling.h"
+
+#include "button_gpio.h"
+#include "common.h"
+#include "driver/gpio.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_mac.h"
+#include "freertos/FreeRTOS.h"
+#include "iot_button.h"
+#include "sdkconfig.h"
+#include <stdio.h>
+#include <string.h>
+
+static const char *TAG = "button_handling";
+
+const uint8_t gpios[] = {BUTTON_DOWN, BUTTON_UP, BUTTON_LEFT, BUTTON_RIGHT, BUTTON_SELECT, BUTTON_BACK};
+
+typedef struct
+{
+    uint8_t gpio;
+} button_user_data_t;
+
+static button_user_data_t button_data[6];
+
+QueueHandle_t buttonQueue = NULL;
+
+static void button_event_cb(void *arg, void *usr_data)
+{
+    if (buttonQueue == NULL)
+    {
+        ESP_LOGE(TAG, "Button queue not initialized!");
+        return;
+    }
+    button_user_data_t *data = (button_user_data_t *)usr_data;
+    uint8_t gpio_num = data->gpio;
+
+    ESP_LOGI(TAG, "Button pressed on GPIO %d", gpio_num);
+
+    if (xQueueSend(buttonQueue, &gpio_num, 0) != pdTRUE)
+    {
+        ESP_LOGW(TAG, "Failed to send button press to queue");
+    }
+}
+
+static void init_button(uint8_t gpio, int index)
+{
+    const button_config_t btn_cfg = {0};
+    const button_gpio_config_t btn_gpio_cfg = {
+        .gpio_num = gpio,
+        .active_level = 0,
+        .enable_power_save = true,
+    };
+    button_handle_t gpio_btn = NULL;
+    const esp_err_t ret = iot_button_new_gpio_device(&btn_cfg, &btn_gpio_cfg, &gpio_btn);
+    if (ret != ESP_OK)
+    {
+        ESP_LOGE(TAG, "Button create failed");
+    }
+
+    button_data[index].gpio = gpio;
+    iot_button_register_cb(gpio_btn, BUTTON_SINGLE_CLICK, NULL, button_event_cb, &button_data[index]);
+}
+
+void setup_buttons(void)
+{
+    buttonQueue = xQueueCreate(10, sizeof(uint8_t));
+    if (buttonQueue == NULL)
+    {
+        ESP_LOGE(TAG, "Failed to create button queue");
+        return;
+    }
+
+    ESP_LOGI(TAG, "Button queue created successfully");
+    for (int i = 0; i < sizeof(gpios) / sizeof(gpios[0]); i++)
+    {
+        init_button(gpios[i], i);
+    }
+}
+
+// Cleanup function (optional)
+void cleanup_buttons(void)
+{
+    if (buttonQueue != NULL)
+    {
+        vQueueDelete(buttonQueue);
+    }
+}

firmware/main/button_handling.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    void setup_buttons(void);
+    void cleanup_buttons(void);
+#ifdef __cplusplus
+}
+#endif

firmware/main/idf_component.yml

@@ -3,3 +3,4 @@ dependencies:
     git: https://github.com/olikraus/u8g2.git
 #  u8g2_hal:
 #    git: https://github.com/mkfrey/u8g2-hal-esp-idf.git
+  espressif/button: ^4.1.3

firmware/main/main.cpp

@@ -0,0 +1,38 @@
+#include "app_task.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "led_manager.h"
+#include "led_status.h"
+#include "sdkconfig.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    void app_main(void)
+    {
+        led_status_init(CONFIG_STATUS_WLED_PIN);
+
+        // LED 0: solid red
+        led_behavior_t led0_solid_red = {.mode = LED_MODE_SOLID, .color = {.r = 50, .g = 0, .b = 0}};
+        led_status_set_behavior(0, led0_solid_red);
+
+        // LED 1: fast blinking green (200ms an, 200ms aus)
+        led_behavior_t led1_blink_green = {
+            .mode = LED_MODE_BLINK, .color = {.r = 0, .g = 50, .b = 0}, .on_time_ms = 200, .off_time_ms = 200};
+        led_status_set_behavior(1, led1_blink_green);
+
+        // LED 2: slow blinking blue (1000ms an, 500ms aus)
+        led_behavior_t led2_blink_blue = {
+            .mode = LED_MODE_BLINK, .color = {.r = 0, .g = 0, .b = 50}, .on_time_ms = 1000, .off_time_ms = 500};
+        led_status_set_behavior(2, led2_blink_blue);
+
+        xTaskCreatePinnedToCore(app_task, "main_loop", 4096, NULL, tskIDLE_PRIORITY + 1, NULL, portNUM_PROCESSORS - 1);
+
+        wled_init();
+        register_handler();
+    }
+#ifdef __cplusplus
+}
+#endif