updated esp-idf version in github action

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

.github/workflows/esp32_build.yml

@@ -19,7 +19,7 @@ jobs:
   build:
     strategy:
       matrix:
-        idf_ver: [release-v5.4, latest]
+        idf_ver: [release-v5.4, release-v5.5, latest]
         idf_target: [esp32c3, esp32h2, esp32s3, esp32p4]
 
     runs-on: ubuntu-latest

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

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 ()

components/insa/CMakeLists.txt

@@ -16,12 +16,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 +38,6 @@ target_include_directories(${PROJECT_NAME} PUBLIC include)
 
 target_link_libraries(${PROJECT_NAME} PRIVATE
         u8g2
+        led-manager
+        persistence-manager
 )

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;

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

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};

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};

components/insa/include/ui/ScreenSaver.h

@@ -1,9 +1,9 @@
 /**
  * @file ScreenSaver.h
- * @brief Animated screensaver implementation with starfield effect
+ * @brief Animated screensaver implementation with vehicle effect
  * @details This header defines the ScreenSaver class which provides an animated
- *          starfield screensaver that activates during periods of user inactivity.
+ *          vehicle screensaver that activates during periods of user inactivity.
- *          The screensaver displays moving stars to prevent screen burn-in while
+ *          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
@@ -17,381 +17,126 @@
 
 /**
  * @class ScreenSaver
- * @brief Animated starfield screensaver widget for system idle periods
+ * @brief Animated vehicle 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
+     * @enum VehicleType
-     * @brief Individual star object structure for starfield animation
+     * @brief Types of available vehicles
-     * @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
+    enum class VehicleType
     {
-        float x;        ///< Horizontal position coordinate (screen-relative)
+        CAR,
-        float y;        ///< Vertical position coordinate (screen-relative)  
+        CONVERTABLE,
-        float z;        ///< Depth coordinate (determines speed and perspective)
+        SUV,
-        float speed;    ///< Individual speed multiplier for animation variation
+        LORRY,
+        TRUCK
     };
 
     /**
-     * @brief Pointer to menu options configuration structure
+     * @enum Direction
-     * @details Stores a reference to the menu configuration passed during construction.
+     * @brief Movement direction for vehicles
-     *          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.
      */
+    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;
-    
-    /**
-     * @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;
+    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 Vector container for all star objects in the starfield
+     * @brief Initialize vehicle system
-     * @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;
+    void initVehicles();
 
     /**
-     * @brief Total number of stars in the animated starfield
+     * @brief Spawn a new vehicle if conditions are met
-     * @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;
+    void trySpawnVehicle();
 
     /**
-     * @brief Global speed multiplier for star animation
+     * @brief Get a random vehicle type
-     * @details Controls the overall speed of star movement in the starfield animation.
+     * @return Random VehicleType
-     *          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;
+    static VehicleType getRandomVehicleType();
 
     /**
-     * @brief Near clipping plane for 3D starfield depth range
+     * @brief Get a random direction with constraint checking
-     * @details Defines the closest distance (minimum z-coordinate) at which stars
+     * @return Direction for new vehicle
-     *          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;
+    static Direction getRandomDirection();
 
     /**
-     * @brief Far clipping plane for 3D starfield depth range  
+     * @brief Draw a vehicle at a specified position
-     * @details Defines the farthest distance (maximum z-coordinate) at which stars
+     * @param vehicle Vehicle to draw
-     *          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;
+    void drawVehicle(const Vehicle &vehicle) const;
 
     /**
-     * @brief Initializes all stars with random positions and properties
+     * @brief Draw a bitmap with transparency (black pixels are transparent)
-     * @details Private helper method that sets up the initial starfield by placing
+     * @param x X position
-     *          all stars at random positions within the defined 3D space. Called
+     * @param y Y position
-     *          during construction to prepare the starfield for immediate animation.
+     * @param width Bitmap width
-     * 
+     * @param height Bitmap height
-     * The initialization process:
+     * @param bitmap Bitmap data
-     * - 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();
+    void drawTransparentBitmap(int x, int y, int width, int height, const unsigned char *bitmap) const;
 
     /**
-     * @brief Resets a single star to a new random position for recycling
+     * @brief Get vehicle bitmap data
-     * @param star Reference to the Star object to be reset and repositioned
+     * @param type Vehicle type
-     * 
+     * @param direction Movement direction
-     * @details Private helper method that recycles individual stars that have
+     * @param width Output parameter for bitmap width
-     *          moved beyond the visible screen boundaries. This enables infinite
+     * @param height Output parameter for bitmap height
-     *          starfield animation by continuously introducing new stars while
+     * @return Pointer to bitmap data
-     *          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);
+    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;
 };

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)
 {
 }

components/insa/src/ui/LightMenu.cpp

@@ -1,5 +1,6 @@
 #include "ui/LightMenu.h"
 
+#include "led_manager.h"
 #include "ui/LightSettingsMenu.h"
 
 /**
@@ -17,7 +18,7 @@ namespace LightMenuOptions
 {
 constexpr std::string LIGHT_ACTIVE = "light_active";
 constexpr std::string LIGHT_MODE = "light_mode";
-}
+} // namespace LightMenuOptions
 
 LightMenu::LightMenu(menu_options_t *options) : Menu(options), m_options(options)
 {
@@ -56,6 +57,16 @@ void LightMenu::onButtonPressed(const MenuItem &menuItem, const ButtonType butto
         if (button == ButtonType::SELECT)
         {
             toggle(menuItem);
+            if (getItem(menuItem.getId()).getValue() == "1")
+            {
+                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";

components/insa/src/ui/ScreenSaver.cpp

@@ -1,86 +1,322 @@
 #include "ui/ScreenSaver.h"
-#include <cmath>
+#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)
+ScreenSaver::ScreenSaver(menu_options_t *options)
+    : Widget(options->u8g2), m_options(options), m_animationCounter(0), m_lastSpawnTime(0), m_leftVehicleCount(0),
+      m_rightVehicleCount(0)
 {
-    initStars();
+    initVehicles();
 }
 
-void ScreenSaver::initStars()
+void ScreenSaver::initVehicles()
 {
-    m_stars.resize(NUM_STARS);
+    m_vehicles.resize(MAX_VEHICLES);
 
-    for (auto &star : m_stars)
+    for (auto &vehicle : m_vehicles)
     {
-        resetStar(star);
+        vehicle.active = false;
-        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;
+    m_lastSpawnTime += dt;
+    m_sceneShiftTimer += dt;
 
-    if (m_animationCounter > 8)
+    // 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 &star : m_stars)
+        for (auto &vehicle : m_vehicles)
         {
-            star.z -= star.speed * SPEED_MULTIPLIER;
+            if (!vehicle.active)
+                continue;
 
-            if (star.z < Z_NEAR)
+            // Move vehicle
+            if (vehicle.direction == Direction::LEFT)
             {
-                resetStar(star);
+                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()
 {
-    // Verwende Page-Buffer Mode statt Full-Buffer für bessere Performance
+    // Clear screen with a black background
-    // 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;
+    // Calculate offsets
-    const int centerY = u8g2->height / 2;
+    const int roadOffset = (m_animationCounter / 100) % road_horizontal_width;
 
-    // Zeichne nur sichtbare Sterne (Clipping)
+    // Draw all active vehicles with a scene offset
-    for (const auto &star : m_stars)
+    for (const auto &vehicle : m_vehicles)
     {
-        // 3D zu 2D Projektion
+        if (vehicle.active)
-        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;
+            Vehicle offsetVehicle = vehicle;
+            offsetVehicle.x += m_sceneOffsetX;
+            offsetVehicle.y += m_sceneOffsetY;
+            drawVehicle(offsetVehicle);
+        }
     }
 
-        // Vereinfachte Sterndarstellung für bessere Performance
+    // Draw road with offsets
-        int size = static_cast<int>((1.0f - (star.z - Z_NEAR) / (Z_FAR - Z_NEAR)) * 2.0f);
+    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);
+    }
+}
 
-        if (size <= 0)
+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);
                 }
-        else
-        {
-            // Verwende u8g2_DrawCircle für größere Sterne (schneller)
-            u8g2_DrawCircle(u8g2, screenX, screenY, size, U8G2_DRAW_ALL);
             }
+            // 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;
     }
 }
 

components/led-manager/CMakeLists.txt

@@ -0,0 +1,28 @@
+if (DEFINED ENV{IDF_PATH})
+    idf_component_register(SRCS
+                src/hal_esp32/led_manager.cpp
+            INCLUDE_DIRS "include"
+            PRIV_REQUIRES
+                u8g2
+                esp_event
+                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
+)

components/led-manager/idf_component.yml

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

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;
+};

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);

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

@@ -0,0 +1,92 @@
+#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_RGB,
+                                       .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 < 64; i++)
+    {
+        led_strip_set_pixel(led_strip, i, 0, 0, 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,                  // Daten-Pointer
+                                      sizeof(led_event_data_t), // Datengröße
+                                      portMAX_DELAY             // Wartezeit
+    );
+
+    if (err != ESP_OK)
+    {
+        ESP_LOGE("LED", "Failed to post event: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    return ESP_OK;
+}

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);
+}

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;
+}

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
+)

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
+     * @param defaultValue The default value to return if the key is not found
-     * @return The stored value or default value if key doesn't exist
+     * @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;
+    [[nodiscard]] virtual bool GetValueImpl(const std::string& key, bool defaultValue) const = 0;
-    virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
+    [[nodiscard]] virtual int GetValueImpl(const std::string& key, int defaultValue) const = 0;
-    virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
+    [[nodiscard]] virtual float GetValueImpl(const std::string& key, float defaultValue) const = 0;
-    virtual double GetValueImpl(const std::string& key, double defaultValue) const = 0;
+    [[nodiscard]] 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 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
         }
     }
 };

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;

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::unordered_map<std::string, ValueType> m_data;
-    std::string filename_;
+    std::string m_filename;
 
 public:
     explicit PersistenceManager(std::string  filename = "settings.dat");
     ~PersistenceManager() override;
 
-    // IPersistenceManager implementation
+    [[nodiscard]] bool HasKey(const std::string& key) const override;
-    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;
+    [[nodiscard]] bool GetValueImpl(const std::string& key, bool defaultValue) const override;
-    int GetValueImpl(const std::string& key, int defaultValue) const override;
+    [[nodiscard]] int GetValueImpl(const std::string& key, int defaultValue) const override;
-    float GetValueImpl(const std::string& key, float defaultValue) const override;
+    [[nodiscard]] float GetValueImpl(const std::string& key, float defaultValue) const override;
-    double GetValueImpl(const std::string& key, double defaultValue) const override;
+    [[nodiscard]] double GetValueImpl(const std::string& key, double defaultValue) const override;
-    std::string GetValueImpl(const std::string& key, const std::string& 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) ;
 

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

@@ -1,5 +1,4 @@
-#ifdef ESP_PLATFORM
+#include "hal_esp32/PersistenceManager.h"
-#include "common/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

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;
+}

main/CMakeLists.txt

@@ -1,12 +1,16 @@
 idf_component_register(SRCS 
-    "main.cpp"
+        main.cpp
-    "app_task.cpp"
+        app_task.cpp
-    "button_handling.c"
+        ../components/persistence-manager/src/hal_esp32/PersistenceManager.cpp
-    "hal/u8g2_esp32_hal.c"
+        button_handling.c
+        hal/u8g2_esp32_hal.c
     INCLUDE_DIRS "."
     PRIV_REQUIRES
         insa
+        led-manager
+        persistence-manager
         u8g2
         driver
         esp_timer
+        esp_event
 )

main/Kconfig.projbuild

@@ -0,0 +1,7 @@
+menu "Warnemuende Lighthouse"
+    config WLED_DIN_PIN
+        int "WLED Data In Pin"
+        default 14
+        help
+            The number of the WLED data in pin.
+endmenu

main/app_task.cpp

@@ -7,7 +7,7 @@
 
 #include "button_handling.h"
 #include "common/InactivityTracker.h"
-#include "common/PersistenceManager.h"
+#include "hal_esp32/PersistenceManager.h"
 #include "ui/ScreenSaver.h"
 #include "ui/SplashScreen.h"
 
@@ -101,7 +101,6 @@ 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);

main/button_handling.c

@@ -1,155 +1,86 @@
 #include "button_handling.h"
 
+#include "button_gpio.h"
+#include "common.h"
 #include "driver/gpio.h"
-#include "driver/i2c.h"
 #include "esp_err.h"
 #include "esp_log.h"
 #include "esp_mac.h"
-#include "esp_timer.h"
 #include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
+#include "iot_button.h"
-#include "freertos/task.h"
 #include "sdkconfig.h"
 #include <stdio.h>
 #include <string.h>
 
-#include "common.h"
-
 static const char *TAG = "button_handling";
 
-#define DEBOUNCE_TIME_MS (50) // Shorter debounce time for timer-based debouncing
+const uint8_t gpios[] = {BUTTON_DOWN, BUTTON_UP, BUTTON_LEFT, BUTTON_RIGHT, BUTTON_SELECT, BUTTON_BACK};
-#define BUTTON_QUEUE_LENGTH 5
-#define BUTTON_QUEUE_ITEM_SIZE sizeof(uint8_t)
 
-const uint8_t pins[] = {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;
 
-// Structure for button state
+static void button_event_cb(void *arg, void *usr_data)
-typedef struct
 {
-    uint8_t pin;
+    if (buttonQueue == NULL)
-    esp_timer_handle_t timer;
-    bool is_pressed;
-    int64_t last_interrupt_time;
-} button_state_t;
-
-// Array for button states
-static button_state_t button_states[6];
-
-// Timer callback for debouncing
-static void button_timer_callback(void *arg)
     {
-    button_state_t *button = (button_state_t *)arg;
+        ESP_LOGE(TAG, "Button queue not initialized!");
-
+        return;
-    // Check current GPIO state
-    int level = gpio_get_level(button->pin);
-
-    // Button is pressed (LOW) and was not pressed before
-    if (level == 0 && !button->is_pressed)
-    {
-        button->is_pressed = true;
-
-        // Send button press to queue
-        uint8_t press_signal = button->pin;
-        xQueueSend(buttonQueue, &press_signal, 0);
-
-        ESP_LOGD(TAG, "Button %d pressed", button->pin);
     }
-    // Button is released (HIGH) and was pressed before
+    button_user_data_t *data = (button_user_data_t *)usr_data;
-    else if (level == 1 && button->is_pressed)
+    uint8_t gpio_num = data->gpio;
+
+    ESP_LOGI(TAG, "Button pressed on GPIO %d", gpio_num);
+
+    if (xQueueSend(buttonQueue, &gpio_num, 0) != pdTRUE)
     {
-        button->is_pressed = false;
+        ESP_LOGW(TAG, "Failed to send button press to queue");
-        ESP_LOGD(TAG, "Button %d released", button->pin);
     }
 }
 
-// ISR Handler - only starts the timer
+static void create_button(uint8_t gpio, int index)
-void IRAM_ATTR button_isr_handler(void *arg)
 {
-    button_state_t *button = (button_state_t *)arg;
+    const button_config_t btn_cfg = {0};
-    int64_t now = esp_timer_get_time();
+    const button_gpio_config_t btn_gpio_cfg = {
-
+        .gpio_num = gpio,
-    // Simple time-based debouncing in ISR
+        .active_level = 0,
-    if ((now - button->last_interrupt_time) > (DEBOUNCE_TIME_MS * 1000))
+        .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)
     {
-        button->last_interrupt_time = now;
+        ESP_LOGE(TAG, "Button create failed");
-
-        // Start/restart the timer
-        esp_timer_stop(button->timer);
-        esp_timer_start_once(button->timer, DEBOUNCE_TIME_MS * 1000);
     }
+
+    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(BUTTON_QUEUE_LENGTH, BUTTON_QUEUE_ITEM_SIZE);
+    buttonQueue = xQueueCreate(10, sizeof(uint8_t));
     if (buttonQueue == NULL)
     {
-        ESP_LOGE(TAG, "Error while Queue creation!");
+        ESP_LOGE(TAG, "Failed to create button queue");
         return;
     }
-    ESP_LOGI(TAG, "Button Queue created.");
 
-    esp_err_t isr_service_err = gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
+    ESP_LOGI(TAG, "Button queue created successfully");
-    if (isr_service_err != ESP_OK && isr_service_err != ESP_ERR_INVALID_STATE)
+    for (int i = 0; i < sizeof(gpios) / sizeof(gpios[0]); i++)
     {
-        ESP_LOGE(TAG, "Error in gpio_install_isr_service: %s", esp_err_to_name(isr_service_err));
+        create_button(gpios[i], i);
-    }
-
-    // Timer configuration
-    esp_timer_create_args_t timer_args = {.callback = button_timer_callback, .name = "button_debounce"};
-
-    for (int i = 0; i < sizeof(pins) / sizeof(pins[0]); i++)
-    {
-        const uint8_t pin = pins[i];
-
-        // Initialize button state
-        button_states[i].pin = pin;
-        button_states[i].is_pressed = false;
-        button_states[i].last_interrupt_time = 0;
-
-        // Create timer for this button
-        timer_args.arg = &button_states[i];
-        esp_err_t timer_err = esp_timer_create(&timer_args, &button_states[i].timer);
-        if (timer_err != ESP_OK)
-        {
-            ESP_LOGE(TAG, "Failed to create timer for button %d: %s", pin, esp_err_to_name(timer_err));
-            continue;
-        }
-
-        // GPIO configuration
-        gpio_config_t io_conf = {.intr_type = GPIO_INTR_ANYEDGE, // React to both edges
-                                 .pin_bit_mask = (1ULL << pin),
-                                 .mode = GPIO_MODE_INPUT,
-                                 .pull_up_en = GPIO_PULLUP_ENABLE,
-                                 .pull_down_en = GPIO_PULLDOWN_DISABLE};
-        gpio_config(&io_conf);
-
-        // Add ISR handler
-        esp_err_t add_isr_err = gpio_isr_handler_add(pin, button_isr_handler, &button_states[i]);
-        if (add_isr_err != ESP_OK)
-        {
-            ESP_LOGE(TAG, "Error in gpio_isr_handler_add: %s", esp_err_to_name(add_isr_err));
-        }
-
-        ESP_LOGD(TAG, "Button interrupt configured for GPIO %d", pin);
     }
 }
 
 // Cleanup function (optional)
 void cleanup_buttons(void)
 {
-    for (int i = 0; i < sizeof(pins) / sizeof(pins[0]); i++)
-    {
-        if (button_states[i].timer != NULL)
-        {
-            esp_timer_stop(button_states[i].timer);
-            esp_timer_delete(button_states[i].timer);
-        }
-        gpio_isr_handler_remove(button_states[i].pin);
-    }
-
     if (buttonQueue != NULL)
     {
         vQueueDelete(buttonQueue);

main/button_handling.h

@@ -1,82 +1,10 @@
-/**
- * @file button_handling.h
- * @brief Button input handling system for user interface interaction
- * @details This header defines the button handling subsystem which manages
- *          hardware button inputs, debouncing, interrupt processing, and
- *          event queue management. It provides a robust foundation for
- *          reliable user input processing in embedded applications.
- * @author System Control Team
- * @date 2025-06-20
- */
-
 #pragma once
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
-    /**
-     * @brief Initializes the button handling subsystem and configures hardware
-     * 
-     * @details This function sets up the complete button handling infrastructure:
-     *          - GPIO configuration for button input pins with pull-up resistors
-     *          - Interrupt service routine installation for responsive input
-     *          - Debouncing timer creation and configuration
-     *          - FreeRTOS queue creation for button event buffering
-     *          - Button state tracking structure initialization
-     * 
-     * The function configures all defined button pins to trigger interrupts
-     * on both rising and falling edges, enabling detection of both press
-     * and release events. Each button uses a dedicated timer for debouncing
-     * to ensure reliable input processing even with mechanical switch bounce.
-     * 
-     * Button events are queued using FreeRTOS queues to ensure no input
-     * events are lost during high system activity periods. The queue-based
-     * approach also decouples interrupt handling from application processing.
-     * 
-     * @pre ESP32 GPIO and timer subsystems must be available and functional
-     * @pre FreeRTOS must be running and queue services available
-     * @post All button pins are configured and ready for input detection
-     * @post Button event queue is created and ready for event processing
-     * @post Interrupt handlers are installed and active
-     * 
-     * @note This function must be called during system initialization before
-     *       any button input processing is expected
-     * @note The function configures hardware-specific GPIO pins as defined
-     *       in the project configuration
-     * 
-     * @see cleanup_buttons() for proper resource cleanup
-     */
     void setup_buttons(void);
-
-    /**
-     * @brief Cleans up button handling resources and disables interrupts
-     * 
-     * @details This function performs complete cleanup of the button handling
-     *          subsystem by:
-     *          - Stopping and deleting all debouncing timers
-     *          - Removing GPIO interrupt handlers from all button pins
-     *          - Deleting the button event queue and freeing associated memory
-     *          - Resetting button state tracking structures
-     * 
-     * This cleanup function ensures proper resource management and prevents
-     * memory leaks when the button handling subsystem is no longer needed.
-     * It can be called during system shutdown or when reconfiguring the
-     * input handling subsystem.
-     * 
-     * @pre Button handling subsystem must have been previously initialized
-     * @post All button-related interrupts are disabled and handlers removed
-     * @post All timers are stopped and deleted, freeing system resources
-     * @post Button event queue is deleted and memory is released
-     * @post GPIO pins are returned to default state
-     * 
-     * @note This function should be called during system shutdown or when
-     *       button handling is no longer required
-     * @note After calling this function, setup_buttons() must be called
-     *       again before button input can be processed
-     * 
-     * @see setup_buttons() for initialization of the button handling system
-     */
     void cleanup_buttons(void);
 #ifdef __cplusplus
 }

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

main/main.cpp

@@ -1,5 +1,7 @@
 #include "app_task.h"
+#include "esp_event.h"
 #include "freertos/FreeRTOS.h"
+#include "led_manager.h"
 #include "sdkconfig.h"
 
 #ifdef __cplusplus
@@ -9,6 +11,9 @@ extern "C"
     void app_main(void)
     {
         xTaskCreatePinnedToCore(app_task, "main_loop", 4096, NULL, tskIDLE_PRIORITY + 1, NULL, portNUM_PROCESSORS - 1);
+
+        wled_init();
+        register_handler();
     }
 #ifdef __cplusplus
 }

src/debug/debug_overlay.cpp

@@ -1,10 +1,10 @@
-#include "debug/DebugOverlay.h"
+#include "debug/debug_overlay.h"
 
 #include "Common.h"
+#include "Matrix.h"
 #include "Version.h"
 #include "imgui.h"
 #include "imgui_impl_sdl3.h"
-#include "ui/Matrix.h"
 #include <imgui_impl_sdlrenderer3.h>
 
 namespace DebugOverlay
@@ -29,22 +29,38 @@ void Update(AppContext *context, const SDL_Event *event)
 
     if (show_led_matrix)
     {
-        if (context->LedMatrixWindow() == nullptr)
+        if (!context->LedMatrixRenderer())
         {
-            const auto win = CreateWindow("LED Matrix", 32 * 50, 8 * 50);
+            const auto win = CreateWindow("LED Matrix", width * 50, height * 50);
             SDL_SetWindowFocusable(win->window(), false);
             SDL_SetRenderVSync(win->renderer(), SDL_RENDERER_VSYNC_ADAPTIVE);
             SDL_SetWindowPosition(win->window(), 0, 0);
             SDL_ShowWindow(win->window());
 
-            context->SetMatrix(new Matrix(win));
+            const auto windowId = SDL_GetWindowID(win->window());
+            context->SetMatrix(new Matrix(windowId, win->renderer(), width, height));
         }
     }
     else
     {
-        if (context->LedMatrixWindow() != nullptr)
+        if (context->LedMatrixRenderer())
         {
-            SDL_DestroyWindow(context->LedMatrixWindow());
+            int window_count = 0;
+            if (SDL_Window **windows = SDL_GetWindows(&window_count))
+            {
+                for (int i = 0; i < window_count; ++i)
+                {
+                    if (SDL_Window *window = windows[i]; context->LedMatrixId() == SDL_GetWindowID(window))
+                    {
+                        SDL_DestroyRenderer(context->LedMatrixRenderer());
+                        SDL_DestroyWindow(window);
+                        break;
+                    }
+                }
+                SDL_free(windows);
+            }
+
+            SDL_DestroyRenderer(context->LedMatrixRenderer());
 
             context->SetMatrix(nullptr);
         }

src/debug/debug_overlay.h

@@ -10,6 +10,9 @@ inline bool show_debug_window = false;
 inline bool show_unhandled_events = false;
 inline bool show_led_matrix = false;
 
+constexpr auto width = 8;
+constexpr auto height = 8;
+
 void Init(const AppContext *context);
 
 void Update(AppContext *context, const SDL_Event *event);
@@ -17,4 +20,4 @@ void Update(AppContext *context, const SDL_Event *event);
 void Render(const AppContext *context);
 
 void Cleanup();
-}
+} // namespace DebugOverlay

src/main.cpp

@@ -5,10 +5,10 @@
 #include <u8g2.h>
 
 #include "Common.h"
-#include "debug/DebugOverlay.h"
+#include "common/Common.h"
+#include "debug/debug_overlay.h"
 #include "hal/u8g2_hal_sdl.h"
 #include "model/AppContext.h"
-#include "common/Common.h"
 #include "ui/Device.h"
 #include "ui/UIWidget.h"
 #include "ui/widgets/Button.h"

src/manager/PersistenceManager.cpp

@@ -1,304 +0,0 @@
-#include "PersistenceManager.h"
-#include <SDL3/SDL.h>
-
-#include <utility>
-
-#ifndef ESP_PLATFORM
-PersistenceManager::PersistenceManager(std::string filename)
-    : filename_(std::move(filename)) {
-    // Initialize SDL3 if not already done
-    if (!SDL_WasInit(SDL_INIT_EVENTS)) {
-        SDL_Init(SDL_INIT_EVENTS);
-    }
-}
-
-PersistenceManager::~PersistenceManager() {
-    Save(); // Automatically save on destruction
-}
-
-bool PersistenceManager::HasKey(const std::string& key) const {
-    return data_.contains(key);
-}
-
-void PersistenceManager::RemoveKey(const std::string& key) {
-    data_.erase(key);
-}
-
-void PersistenceManager::Clear() {
-    data_.clear();
-}
-
-bool PersistenceManager::Save() {
-    return SaveToFile(filename_);
-}
-
-bool PersistenceManager::Load() {
-    return LoadFromFile(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;
-    }
-
-    // Write number of entries
-    const size_t count = data_.size();
-    if (SDL_WriteIO(stream, &count, sizeof(count)) != sizeof(count)) {
-        SDL_Log("Error writing count: %s", SDL_GetError());
-        SDL_CloseIO(stream);
-        return false;
-    }
-
-    // Write each entry
-    for (const auto& [key, value] : data_) {
-        // Write key length
-        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;
-        }
-
-        // Write key
-        if (SDL_WriteIO(stream, key.c_str(), keyLength) != keyLength) {
-            SDL_Log("Error writing key: %s", SDL_GetError());
-            SDL_CloseIO(stream);
-            return false;
-        }
-
-        // Write value
-        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;
-    }
-
-    data_.clear();
-
-    // Read number of entries
-    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;
-    }
-
-    // Read each entry
-    for (size_t i = 0; i < count; ++i) {
-        // Read key length
-        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;
-        }
-
-        // Read key
-        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;
-        }
-
-        // Read value
-        ValueType value;
-        if (!ReadValueFromStream(stream, value)) {
-            SDL_CloseIO(stream);
-            return false;
-        }
-
-        data_[key] = value;
-    }
-
-    SDL_CloseIO(stream);
-    return true;
-}
-
-// Template-specific implementations
-void PersistenceManager::SetValueImpl(const std::string& key, bool value) {
-    data_[key] = value;
-}
-
-void PersistenceManager::SetValueImpl(const std::string& key, int value) {
-    data_[key] = value;
-}
-
-void PersistenceManager::SetValueImpl(const std::string& key, float value) {
-    data_[key] = value;
-}
-
-void PersistenceManager::SetValueImpl(const std::string& key, double value) {
-    data_[key] = value;
-}
-
-void PersistenceManager::SetValueImpl(const std::string& key, const std::string& value) {
-    data_[key] = value;
-}
-
-bool PersistenceManager::GetValueImpl(const std::string& key, bool defaultValue) const {
-    if (const auto it = data_.find(key); it != 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 = data_.find(key); it != 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 = data_.find(key); it != 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 = data_.find(key); it != 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 = data_.find(key); it != data_.end() && std::holds_alternative<std::string>(it->second)) {
-        return std::get<std::string>(it->second);
-    }
-    return defaultValue;
-}
-
-// Private helper methods
-bool PersistenceManager::WriteValueToStream(SDL_IOStream* stream, const ValueType& value) {
-    const TypeId typeId = GetTypeId(value);
-    
-    // Write type ID
-    if (SDL_WriteIO(stream, &typeId, sizeof(typeId)) != sizeof(typeId)) {
-        SDL_Log("Error writing type ID: %s", SDL_GetError());
-        return false;
-    }
-
-    // Write value based on type
-    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();
-            
-            // Write string length
-            if (SDL_WriteIO(stream, &length, sizeof(length)) != sizeof(length)) {
-                return false;
-            }
-            
-            // Write string data
-            return SDL_WriteIO(stream, str.c_str(), length) == length;
-        }
-    }
-    return false;
-}
-
-bool PersistenceManager::ReadValueFromStream(SDL_IOStream* stream, ValueType& value) {
-    TypeId typeId;
-    
-    // Read type ID
-    if (SDL_ReadIO(stream, &typeId, sizeof(typeId)) != sizeof(typeId)) {
-        SDL_Log("Error reading type ID: %s", SDL_GetError());
-        return false;
-    }
-
-    // Read value based on type
-    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;
-    
-    // Should never be reached
-    return TypeId::BOOL;
-}
-#endif // !ESP_PLATFORM

src/model/AppContext.cpp

@@ -1,6 +1,6 @@
 #include "model/AppContext.h"
 
-#include "ui/Matrix.h"
+#include "Matrix.h"
 
 auto AppContext::MainWindow() const -> SDL_Window *
 {
@@ -27,27 +27,27 @@ auto AppContext::LedMatrix() const -> Matrix *
     return m_matrix;
 }
 
-auto AppContext::LedMatrixWindow() const -> SDL_Window *
+auto AppContext::LedMatrixId() const -> SDL_WindowID
 {
-    if (m_matrix && m_matrix->window())
+    if (m_matrix)
     {
-        return m_matrix->window()->window();
+        return m_matrix->windowId();
     }
-    return nullptr;
+    return 0;
 }
 
 auto AppContext::LedMatrixRenderer() const -> SDL_Renderer *
 {
-    if (m_matrix && m_matrix->window())
+    if (m_matrix && m_matrix->renderer())
     {
-        return m_matrix->window()->renderer();
+        return m_matrix->renderer();
     }
     return nullptr;
 }
 
 void AppContext::Render() const
 {
-    if (m_matrix && m_matrix->window())
+    if (m_matrix && m_matrix->renderer())
     {
         m_matrix->Render();
     }

src/model/AppContext.h

@@ -30,7 +30,7 @@ class AppContext
 
     [[nodiscard]] auto LedMatrix() const -> Matrix *;
 
-    [[nodiscard]] auto LedMatrixWindow() const -> SDL_Window *;
+    [[nodiscard]] auto LedMatrixId() const -> SDL_WindowID;
 
     [[nodiscard]] auto LedMatrixRenderer() const -> SDL_Renderer *;
 

src/ui/Device.cpp

@@ -5,7 +5,7 @@
 
 #include "MenuOptions.h"
 #include "common/InactivityTracker.h"
-#include "manager/PersistenceManager.h"
+#include "hal_native/PersistenceManager.h"
 #include "ui/ScreenSaver.h"
 #include "ui/SplashScreen.h"
 #include "ui/widgets/Button.h"

src/ui/Matrix.cpp

@@ -1,56 +0,0 @@
-#include "ui/Matrix.h"
-
-Matrix::Matrix(Window *window) : m_window(window)
-{
-}
-
-Window *Matrix::window() const
-{
-    return m_window;
-}
-
-void Matrix::DrawColoredGrid(const int rows, const int cols, const float cellSize, const float spacing) const
-{
-    int i = 0;
-    for (int w = 0; w < cols; w++)
-    {
-        const auto phase = w % (2 * rows);
-
-        for (int h_raw = 0; h_raw < rows; h_raw++)
-        {
-            int h;
-            if (phase < rows)
-            {
-                h = h_raw;
-            }
-            else
-            {
-                h = rows - 1 - h_raw;
-            }
-
-            const 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_window->renderer(), red, green, blue, 255);
-            SDL_RenderFillRect(m_window->renderer(), &rect);
-        }
-    }
-}
-
-void Matrix::Render() const
-{
-    SDL_SetRenderDrawColor(m_window->renderer(), 0, 0, 0, 255);
-    SDL_RenderClear(m_window->renderer());
-
-    DrawColoredGrid(8, 32, 50.0f, 1.0f);
-
-    SDL_RenderPresent(m_window->renderer());
-}

src/ui/Matrix.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "model/Window.h"
-
-class Matrix
-{
-  public:
-    explicit Matrix(Window *window);
-
-    [[nodiscard]] Window *window() const;
-
-    void Render() const;
-
-  private:
-    void DrawColoredGrid(int rows, int cols, float cellSize, float spacing) const;
-
-    Window *m_window;
-};