model-railway/system-control
1
0
Fork 0
Code Issues 1 Pull Requests Releases Activity

code cleanup

Browse Source 
Signed-off-by: Peter Siegmund <developer@mars3142.org>
This commit is contained in:
Peter Siegmund
2025-06-20 21:21:06 +02:00
parent 54080bfd9d
commit 26723db8d8
19 changed files with 50 additions and 316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
components/CMakeLists.txt
View File

@@ -3,7 +3,6 @@ if (NOT DEFINED ENV{IDF_PATH})
add_subdirectory(imgui)
add_subdirectory(insa)
add_subdirectory(ruth)
target_link_libraries(components INTERFACE ImGui)
endif ()

10
components/bob/CMakeLists.txt
View File

@@ -1,10 +0,0 @@
if (DEFINED ENV{IDF_PATH})
idf_component_register(SRCS
bob.c
INCLUDE_DIRS "include"
PRIV_REQUIRES
bt
ruth
)
return()
endif ()

8
components/bob/bob.c
View File

@@ -1,8 +0,0 @@
#include "bob.h"
#include "persistence.h"
void bob_init(void)
{
persistence_init("system_control");
}

10
components/bob/include/bob.h
View File

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

43
components/insa/CMakeLists.txt
View File

@@ -1,19 +1,23 @@
# Definiere die Quelldateien in einer Variable
set(SOURCE_FILES
src/common/InactivityTracker.cpp
src/common/Menu.cpp
src/common/ScrollBar.cpp
src/common/Widget.cpp
src/data/MenuItem.cpp
src/ui/LightMenu.cpp
src/ui/LightSettingsMenu.cpp
src/ui/MainMenu.cpp
src/ui/ScreenSaver.cpp
src/ui/SettingsMenu.cpp
src/ui/SplashScreen.cpp
)
if (DEFINED ENV{IDF_PATH})
idf_component_register(SRCS
src/common/InactivityTracker.cpp
src/common/Menu.cpp
src/common/ScrollBar.cpp
src/common/Widget.cpp
src/data/MenuItem.cpp
src/ui/LightMenu.cpp
src/ui/LightSettingsMenu.cpp
src/ui/MainMenu.cpp
src/ui/ScreenSaver.cpp
src/ui/SettingsMenu.cpp
src/ui/SplashScreen.cpp
${SOURCE_FILES}
INCLUDE_DIRS "include"
PRIV_REQUIRES
ruth
u8g2
)
return()
@@ -23,17 +27,7 @@ cmake_minimum_required(VERSION 3.30)
project(insa)
add_library(${PROJECT_NAME} STATIC
src/common/InactivityTracker.cpp
src/common/Menu.cpp
src/common/ScrollBar.cpp
src/common/Widget.cpp
src/data/MenuItem.cpp
src/ui/LightMenu.cpp
src/ui/LightSettingsMenu.cpp
src/ui/MainMenu.cpp
src/ui/ScreenSaver.cpp
src/ui/SettingsMenu.cpp
src/ui/SplashScreen.cpp
${SOURCE_FILES}
)
include_directories(include)
@@ -42,5 +36,4 @@ target_include_directories(${PROJECT_NAME} PUBLIC include)
target_link_libraries(${PROJECT_NAME} PRIVATE
u8g2
ruth
)
)

3
components/insa/include/MenuOptions.h
View File

@@ -16,7 +16,6 @@
#include <memory>
// Project-specific headers
#include "persistence.h"
#include "common/Widget.h"
#include "u8g2.h"
@@ -124,6 +123,4 @@ typedef struct
* @see Widget::onButtonClicked for widget-specific button handling
*/
std::function<void(ButtonType button)> onButtonClicked;
persistence_t *persistence;
} menu_options_t;

61
components/insa/include/common/InactivityTracker.h
View File

@@ -12,6 +12,7 @@
#pragma once
#include <functional>
#include <stdint.h>
/**
* @class InactivityTracker
@@ -21,21 +22,21 @@
* configured timeout period. It is commonly used for implementing power
* saving features, automatic screen savers, session timeouts, and other
* time-based system behaviors.
*
*
* The InactivityTracker operates by:
* - Continuously tracking elapsed time since the last user activity
* - Comparing elapsed time against a configurable timeout threshold
* - Executing a callback function when the timeout is reached
* - Providing methods to reset the timer when activity is detected
* - Supporting enable/disable functionality for dynamic control
*
*
* Key features include:
* - Configurable timeout duration in milliseconds
* - Custom callback function execution on timeout
* - Activity reset capability for responsive user interaction
* - Enable/disable control for conditional monitoring
* - High-resolution timing support using 64-bit millisecond precision
*
*
* Common use cases:
* - Screen saver activation after idle periods
* - Automatic screen dimming or shutdown
@@ -43,14 +44,14 @@
* - Power management and battery conservation
* - User interface state transitions
* - Security lockout after inactivity
*
*
* The class is designed to be lightweight and efficient, suitable for
* real-time applications where precise timing and minimal overhead are important.
*
*
* @note This class requires regular update calls to function properly.
* @note The timeout callback is executed once per timeout period and will
* not repeat until the tracker is reset and times out again.
*
*
* @see Widget for integration with UI components
* @see Menu for menu timeout implementations
*/
@@ -61,15 +62,15 @@ class InactivityTracker
* @brief Constructs an InactivityTracker with specified timeout and callback
* @param timeoutMs Timeout duration in milliseconds before triggering callback
* @param onTimeout Callback function to execute when timeout is reached
*
*
* @pre timeoutMs must be greater than 0 for meaningful timeout behavior
* @pre onTimeout must be a valid callable function object
* @post InactivityTracker is initialized, enabled, and ready for activity monitoring
*
*
* @details The constructor initializes the inactivity tracker with the specified
* timeout duration and callback function. The tracker starts in an enabled
* state with zero elapsed time, ready to begin monitoring user activity.
*
*
* The timeout callback function can perform any necessary actions when inactivity
* is detected, such as:
* - Activating screen savers or power saving modes
@@ -77,11 +78,11 @@ class InactivityTracker
* - Logging inactivity events
* - Triggering security lockouts
* - Initiating automatic save operations
*
*
* @note The tracker begins monitoring immediately upon construction.
* @note The callback function should be lightweight to avoid blocking
* the main application thread during timeout processing.
*
*
* Example usage:
* @code
* auto tracker = InactivityTracker(30000, []() {
@@ -95,23 +96,23 @@ class InactivityTracker
/**
* @brief Updates the inactivity timer and checks for timeout conditions
* @param dt Delta time in milliseconds since the last update call
*
*
* @details This method must be called regularly (typically every frame) to
* maintain accurate timing and timeout detection. It increments the
* elapsed time counter and triggers the timeout callback when the
* configured timeout duration is reached.
*
*
* The update process:
* - Adds the delta time to the elapsed time counter (if enabled)
* - Compares elapsed time against the configured timeout threshold
* - Executes the timeout callback if the threshold is exceeded
* - Continues monitoring until reset or disabled
*
*
* @note This method should be called consistently from the main application
* loop to ensure accurate timing behavior.
* @note The timeout callback is executed only once per timeout period.
* @note If the tracker is disabled, elapsed time is not updated.
*
*
* @see reset() to restart the inactivity timer
* @see setEnabled() to control monitoring state
*/
@@ -119,27 +120,27 @@ class InactivityTracker
/**
* @brief Resets the inactivity timer to indicate recent user activity
*
*
* @details This method should be called whenever user activity is detected
* to restart the inactivity timeout period. It resets the elapsed
* time counter to zero, effectively extending the timeout deadline
* and preventing timeout callback execution until the full timeout
* duration elapses again without further resets.
*
*
* Common scenarios for calling reset():
* - Button presses or key events
* - Mouse movement or touch input
* - Menu navigation or selection actions
* - Any user interface interaction
* - System activity that should extend the timeout
*
*
* @post Elapsed time is reset to zero, restarting the timeout period
*
*
* @note This method can be called at any time, even when the tracker
* is disabled, to prepare for future monitoring.
* @note Frequent reset calls from active user interaction will prevent
* timeout callback execution, which is the intended behavior.
*
*
* Example usage:
* @code
* void onButtonPress() {
@@ -153,29 +154,29 @@ class InactivityTracker
/**
* @brief Enables or disables inactivity monitoring
* @param enabled True to enable monitoring, false to disable
*
*
* @details This method controls whether the inactivity tracker actively
* monitors for timeouts. When disabled, the elapsed time counter
* is not updated during update() calls, effectively pausing the
* timeout detection without losing the current elapsed time state.
*
*
* Use cases for disabling:
* - Temporary suspension during system operations
* - Context-sensitive monitoring (disable in certain application states)
* - Power management control (disable during low-power modes)
* - User preference settings (allow users to disable timeouts)
* - Development and debugging (disable for testing)
*
*
* When re-enabled, monitoring resumes from the current elapsed time state,
* allowing for seamless pause/resume functionality.
*
*
* @post Monitoring state is updated according to the enabled parameter
*
*
* @note Disabling the tracker does not reset the elapsed time counter.
* @note The timeout callback will not be executed while disabled, even
* if the timeout threshold would otherwise be exceeded.
* @note Enabling/disabling can be done at any time during operation.
*
*
* Example usage:
* @code
* tracker.setEnabled(false); // Pause monitoring during critical operation
@@ -186,8 +187,8 @@ class InactivityTracker
void setEnabled(bool enabled);
private:
uint64_t m_timeoutMs; ///< Timeout duration in milliseconds before callback execution
uint64_t m_elapsedTime; ///< Current elapsed time since last reset in milliseconds
bool m_enabled; ///< Flag indicating whether monitoring is currently active
std::function<void()> m_onTimeout; ///< Callback function executed when timeout threshold is reached
uint64_t m_timeoutMs; ///< Timeout duration in milliseconds before callback execution
uint64_t m_elapsedTime; ///< Current elapsed time since last reset in milliseconds
bool m_enabled; ///< Flag indicating whether monitoring is currently active
std::function<void()> m_onTimeout; ///< Callback function executed when timeout threshold is reached
};

16
components/insa/src/ui/LightMenu.cpp
View File

@@ -30,7 +30,6 @@ LightMenu::LightMenu(menu_options_t *options) : Menu(options), m_options(options
void LightMenu::onButtonPressed(const MenuItem &menuItem, const ButtonType button)
{
MenuItem item = menuItem;
std::shared_ptr<Widget> widget;
// Handle different menu items based on their ID
@@ -42,25 +41,12 @@ void LightMenu::onButtonPressed(const MenuItem &menuItem, const ButtonType butto
{
toggle(menuItem);
}
if (m_options && m_options->persistence && m_options->persistence->save)
{
const auto value = getItem(item.getId()).getValue();
m_options->persistence->save(VALUE_TYPE_STRING, "light_activated", value.c_str());
}
break;
}
case LightMenuItem::MODE: {
// Switch between day/night modes using left/right buttons
item = switchValue(menuItem, button);
if (button == ButtonType::LEFT || button == ButtonType::RIGHT)
{
if (m_options && m_options->persistence && m_options->persistence->save)
{
const auto value = getItem(item.getId()).getIndex();
m_options->persistence->save(VALUE_TYPE_INT32, "light_mode", &value);
}
}
switchValue(menuItem, button);
break;
}

8
components/insa/src/ui/LightSettingsMenu.cpp
View File

@@ -31,12 +31,4 @@ void LightSettingsMenu::onButtonPressed(const MenuItem &menuItem, const ButtonTy
// Update the section list size based on the section counter value
setItemSize(std::stoull(getItem(0).getValue()));
// Persist the changed section values if persistence is available
if (m_options && m_options->persistence && m_options->persistence->save)
{
const auto key = "section_" + std::to_string(menuItem.getId());
const auto value = getItem(menuItem.getId()).getValue();
m_options->persistence->save(VALUE_TYPE_STRING, key.c_str(), value.c_str());
}
}

20
components/ruth/CMakeLists.txt
View File

@@ -1,20 +0,0 @@
if (DEFINED ENV{IDF_PATH})
idf_component_register(SRCS
espressif/persistence.c
INCLUDE_DIRS "include"
PRIV_REQUIRES
nvs_flash
)
return()
endif ()
cmake_minimum_required(VERSION 3.30)
project(ruth)
add_library(${PROJECT_NAME} STATIC
persistence.c
)
include_directories(include)
target_include_directories(${PROJECT_NAME} PUBLIC include)

116
components/ruth/espressif/persistence.c
View File

@@ -1,116 +0,0 @@
#include "persistence.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "nvs_flash.h"
static const char *TAG = "persistence";
static nvs_handle_t persistence_handle;
static SemaphoreHandle_t persistence_mutex;
void *persistence_init(const char *namespace_name)
{
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
{
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);
ESP_ERROR_CHECK(nvs_open(namespace_name, NVS_READWRITE, &persistence_handle));
persistence_mutex = xSemaphoreCreateMutex();
if (persistence_mutex == NULL)
{
ESP_LOGE(TAG, "Failed to create mutex");
}
return &persistence_handle;
}
void persistence_save(persistence_value_t value_type, const char *key, const void *value)
{
if (persistence_mutex != NULL)
{
if (xSemaphoreTake(persistence_mutex, portMAX_DELAY) == pdTRUE)
{
esp_err_t err = ESP_ERR_INVALID_ARG;
switch (value_type)
{
case VALUE_TYPE_STRING:
err = nvs_set_str(persistence_handle, key, (char *)value);
break;
case VALUE_TYPE_INT32:
err = nvs_set_i32(persistence_handle, key, *(int32_t *)value);
break;
default:
ESP_LOGE(TAG, "Unsupported value type");
break;
}
if (err == ESP_OK)
{
ESP_ERROR_CHECK(nvs_commit(persistence_handle));
}
else
{
ESP_LOGE(TAG, "Error saving key %s: %s", key, esp_err_to_name(err));
}
xSemaphoreGive(persistence_mutex);
}
}
}
void *persistence_load(persistence_value_t value_type, const char *key, void *out)
{
if (persistence_mutex != NULL)
{
if (xSemaphoreTake(persistence_mutex, portMAX_DELAY) == pdTRUE)
{
esp_err_t err = ESP_ERR_INVALID_ARG;
switch (value_type)
{
case VALUE_TYPE_STRING:
err = nvs_get_str(persistence_handle, key, (char *)out, NULL);
break;
case VALUE_TYPE_INT32:
err = nvs_get_i32(persistence_handle, key, (int32_t *)out);
break;
default:
ESP_LOGE(TAG, "Unsupported value type");
break;
}
if (err != ESP_OK)
{
ESP_LOGE(TAG, "Error loading key %s: %s", key, esp_err_to_name(err));
}
xSemaphoreGive(persistence_mutex);
}
}
return out;
}
void persistence_deinit()
{
if (persistence_mutex != NULL)
{
vSemaphoreDelete(persistence_mutex);
persistence_mutex = NULL;
}
nvs_close(persistence_handle);
}

25
components/ruth/include/persistence.h
View File

@@ -1,25 +0,0 @@
#pragma once
typedef enum
{
VALUE_TYPE_STRING,
VALUE_TYPE_INT32,
} persistence_value_t;
typedef struct
{
void *handle;
void (*save)(persistence_value_t value_type, const char *key, const void *value);
} persistence_t;
#ifdef __cplusplus
extern "C"
{
#endif
void *persistence_init(const char *namespace_name);
void persistence_save(persistence_value_t value_type, const char *key, const void *value);
void *persistence_load(persistence_value_t value_type, const char *key, void *out);
void persistence_deinit();
#ifdef __cplusplus
}
#endif

32
components/ruth/persistence.c
View File

@@ -1,32 +0,0 @@
#include "persistence.h"
#include "stddef.h"
#include <stdio.h>
void *persistence_init(const char *namespace_name)
{
return NULL;
}
void persistence_save(const persistence_value_t value_type, const char *key, const void *value)
{
printf("Key: %s - ", key);
switch (value_type)
{
case VALUE_TYPE_STRING:
printf("Value (s): %s\n", (char *)value);
break;
case VALUE_TYPE_INT32:
printf("Value (i): %d\n", *(int32_t *)value);
break;
}
}
void *persistence_load(persistence_value_t value_type, const char *key, void *out)
{
return NULL;
}
void persistence_deinit()
{
}