dominic/Tactility
1
0
Fork 0
mirror of https://github.com/ByteWelder/Tactility.git synced 2026-02-18 02:43:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Kernel and buildscript improvements (#477)

Browse Source 
* **New Features**
  * Centralized module management with global symbol resolution
  * Level-aware logging with colored prefixes and millisecond timestamps

* **Breaking Changes**
  * ModuleParent hierarchy and getModuleParent() removed
  * Logging API and adapter model replaced; LogLevel-driven log_generic signature changed

* **Improvements**
  * Unified, simplified module registration across build targets
  * Tests updated to reflect new module lifecycle and global symbol resolution
This commit is contained in:
Ken Van Hoeylandt 2026-02-03 08:35:29 +01:00 committed by GitHub
parent 1a61eac8e0
commit a935410f82
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
38 changed files with 432 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
Buildscripts/module.cmake Normal file
View File

@ -0,0 +1,29 @@
if (COMMAND tactility_add_module)
return()
endif()
macro(tactility_add_module NAME)
set(options)
set(oneValueArgs)
set(multiValueArgs SRCS INCLUDE_DIRS PRIV_INCLUDE_DIRS REQUIRES PRIV_REQUIRES)
cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if (DEFINED ENV{ESP_IDF_VERSION})
idf_component_register(
SRCS ${ARG_SRCS}
INCLUDE_DIRS ${ARG_INCLUDE_DIRS}
PRIV_INCLUDE_DIRS ${ARG_PRIV_INCLUDE_DIRS}
REQUIRES ${ARG_REQUIRES}
PRIV_REQUIRES ${ARG_PRIV_REQUIRES}
)
else()
add_library(${NAME} OBJECT)
target_sources(${NAME} PRIVATE ${ARG_SRCS})
target_include_directories(${NAME}
PRIVATE ${ARG_PRIV_INCLUDE_DIRS}
PUBLIC ${ARG_INCLUDE_DIRS}
)
target_link_libraries(${NAME} PUBLIC ${ARG_REQUIRES})
target_link_libraries(${NAME} PRIVATE ${ARG_PRIV_REQUIRES})
endif()
endmacro()

6
CMakeLists.txt
View File

@ -12,9 +12,13 @@ set(Cyan "${Esc}[36m")
file(READ version.txt TACTILITY_VERSION)
add_compile_definitions(TT_VERSION="${TACTILITY_VERSION}")
# tactility_add_module() macro
include("Buildscripts/module.cmake")
# Determine device identifier and project location
include("Buildscripts/device.cmake")
if (DEFINED ENV{ESP_IDF_VERSION})
include("Buildscripts/device.cmake")
init_tactility_globals("sdkconfig")
get_property(TACTILITY_DEVICE_PROJECT GLOBAL PROPERTY TACTILITY_DEVICE_PROJECT)
get_property(TACTILITY_DEVICE_ID GLOBAL PROPERTY TACTILITY_DEVICE_ID)

48
Modules/hal-device-module/CMakeLists.txt
View File

@ -1,41 +1,21 @@
cmake_minimum_required(VERSION 3.20)
include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
file(GLOB_RECURSE SOURCE_FILES "Source/*.c*")
if (DEFINED ENV{ESP_IDF_VERSION})
list(APPEND REQUIRES_LIST
TactilityKernel
TactilityCore
TactilityFreeRtos
)
list(APPEND REQUIRES_LIST
TactilityKernel
TactilityCore
TactilityFreeRtos
)
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
REQUIRES ${REQUIRES_LIST}
)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_compile_options(${COMPONENT_LIB} PUBLIC -Wno-unused-variable)
endif ()
else ()
add_library(hal-device-module OBJECT)
target_sources(hal-device-module PRIVATE ${SOURCE_FILES})
target_include_directories(hal-device-module
PUBLIC Include/
)
target_link_libraries(hal-device-module PUBLIC
TactilityFreeRtos
TactilityCore
TactilityKernel
freertos_kernel
)
if (NOT DEFINED ENV{ESP_IDF_VERSION})
list(APPEND REQUIRES_LIST freertos_kernel)
endif ()
tactility_add_module(hal-device-module
SRCS ${SOURCE_FILES}
INCLUDE_DIRS Include/
REQUIRES ${REQUIRES_LIST}
)

2
Modules/hal-device-module/Source/drivers/hal_device.cpp
View File

@ -8,7 +8,7 @@
#include <memory>
#include <utility>
#define TAG LOG_TAG(HalDevice)
#define TAG "HalDevice"
struct HalDevicePrivate {
std::shared_ptr<tt::hal::Device> halDevice;

38
Modules/lvgl-module/CMakeLists.txt
View File

@ -1,30 +1,22 @@
cmake_minimum_required(VERSION 3.20)
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
file(GLOB_RECURSE SOURCE_FILES "Source/*.c*")
list(APPEND REQUIRES_LIST
TactilityKernel
lvgl
)
if (DEFINED ENV{ESP_IDF_VERSION})
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
REQUIRES TactilityKernel lvgl esp_lvgl_port
)
list(APPEND REQUIRES_LIST esp_lvgl_port)
else ()
add_library(lvgl-module OBJECT)
target_sources(lvgl-module PRIVATE ${SOURCE_FILES})
target_include_directories(lvgl-module
PUBLIC Include/
)
target_link_libraries(lvgl-module PUBLIC
TactilityKernel
freertos_kernel
lvgl
)
list(APPEND REQUIRES_LIST freertos_kernel)
endif ()
include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
tactility_add_module(lvgl-module
SRCS ${SOURCE_FILES}
INCLUDE_DIRS Include/
REQUIRES ${REQUIRES_LIST}
)

21
Platforms/PlatformEsp32/CMakeLists.txt
View File

@ -2,19 +2,8 @@ cmake_minimum_required(VERSION 3.20)
file(GLOB_RECURSE SOURCES "Source/*.c**")
if (DEFINED ENV{ESP_IDF_VERSION})
idf_component_register(
SRCS ${SOURCES}
INCLUDE_DIRS "Include/"
REQUIRES TactilityKernel driver
)
else ()
add_library(PlatformEsp32 OBJECT)
target_sources(PlatformEsp32 PRIVATE ${SOURCES})
target_include_directories(PlatformEsp32 PUBLIC Include/)
target_link_libraries(PlatformEsp32 PUBLIC TactilityKernel)
endif ()
idf_component_register(
SRCS ${SOURCES}
INCLUDE_DIRS "Include/"
REQUIRES TactilityKernel driver
)

2
Platforms/PlatformEsp32/Source/drivers/esp32_gpio.cpp
View File

@ -9,7 +9,7 @@
#include <tactility/drivers/gpio.h>
#include <tactility/drivers/gpio_controller.h>
#define TAG LOG_TAG(esp32_gpio)
#define TAG "esp32_gpio"
#define GET_CONFIG(device) ((struct Esp32GpioConfig*)device->config)

2
Platforms/PlatformEsp32/Source/drivers/esp32_i2c.cpp
View File

@ -9,7 +9,7 @@
#include <tactility/error_esp32.h>
#include <tactility/drivers/esp32_i2c.h>
#define TAG LOG_TAG(esp32_i2c)
#define TAG "esp32_i2c"
#define ACK_CHECK_EN 1
struct InternalData {

20
Platforms/PlatformPosix/CMakeLists.txt
View File

@ -2,19 +2,7 @@ cmake_minimum_required(VERSION 3.20)
file(GLOB_RECURSE SOURCES "Source/*.c**")
if (DEFINED ENV{ESP_IDF_VERSION})
idf_component_register(
SRCS ${SOURCES}
# INCLUDE_DIRS "Include/"
REQUIRES TactilityKernel driver
)
else ()
add_library(PlatformPosix OBJECT)
target_sources(PlatformPosix PRIVATE ${SOURCES})
# target_include_directories(PlatformPosix PUBLIC Include/)
target_link_libraries(PlatformPosix PUBLIC TactilityKernel)
endif ()
add_library(PlatformPosix OBJECT)
target_sources(PlatformPosix PRIVATE ${SOURCES})
#target_include_directories(PlatformPosix PUBLIC Include/)
target_link_libraries(PlatformPosix PUBLIC TactilityKernel)

2
Platforms/PlatformPosix/Source/freertos.c
View File

@ -5,7 +5,7 @@
#include <tactility/freertos/task.h>
#include <tactility/log.h>
#define TAG LOG_TAG(freertos)
#define TAG "freertos"
/**
* Assert implementation as defined in the FreeRTOSConfig.h

75
Tactility/CMakeLists.txt
View File

@ -1,26 +1,32 @@
cmake_minimum_required(VERSION 3.20)
include("${CMAKE_CURRENT_LIST_DIR}/../Buildscripts/module.cmake")
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
list(APPEND REQUIRES_LIST
TactilityKernel
TactilityCore
TactilityFreeRtos
hal-device-module
lvgl-module
lv_screenshot
minitar
minmea
)
if (DEFINED ENV{ESP_IDF_VERSION})
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
list(APPEND REQUIRES_LIST
TactilityKernel
PlatformEsp32
TactilityCore
TactilityFreeRtos
hal-device-module
lvgl-module
driver
elf_loader
lv_screenshot
QRCode
esp_http_server
esp_http_client
esp-tls
esp_wifi
json
minitar
minmea
json # Effectively cJSON
nvs_flash
spiffs
vfs
@ -33,13 +39,25 @@ if (DEFINED ENV{ESP_IDF_VERSION})
list(APPEND REQUIRES_LIST esp_tinyusb)
endif ()
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
PRIV_INCLUDE_DIRS "Private/"
REQUIRES ${REQUIRES_LIST}
else ()
list(APPEND REQUIRES_LIST
PlatformPosix
freertos_kernel
cJSON
lvgl
)
endif ()
tactility_add_module(Tactility
SRCS ${SOURCE_FILES}
INCLUDE_DIRS Include/
PRIV_INCLUDE_DIRS Private/
REQUIRES ${REQUIRES_LIST}
)
if (DEFINED ENV{ESP_IDF_VERSION})
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_compile_options(${COMPONENT_LIB} PUBLIC -Wno-unused-variable)
endif ()
@ -50,31 +68,6 @@ if (DEFINED ENV{ESP_IDF_VERSION})
# Read-write
fatfs_create_spiflash_image(data "${CMAKE_CURRENT_SOURCE_DIR}/../Data/data" FLASH_IN_PROJECT PRESERVE_TIME)
endif ()
else()
file(GLOB_RECURSE SOURCES "Source/*.c*")
add_library(Tactility OBJECT)
target_sources(Tactility PRIVATE ${SOURCES})
target_include_directories(Tactility
PRIVATE Private/
PUBLIC Include/
)
target_link_libraries(Tactility PUBLIC
cJSON
TactilityFreeRtos
TactilityCore
TactilityKernel
PlatformPosix
hal-device-module
lvgl-module
freertos_kernel
lvgl
lv_screenshot
minmea
minitar
)
endif()
endif ()

2
Tactility/Include/Tactility/Tactility.h
View File

@ -38,8 +38,6 @@ const Configuration* getConfiguration();
*/
Dispatcher& getMainDispatcher();
ModuleParent& getModuleParent();
namespace hal {
/** While technically this configuration is nullable, it's never null after initHeadless() is called. */

17
Tactility/Source/Tactility.cpp
View File

@ -41,15 +41,6 @@ static auto LOGGER = Logger("Tactility");
static const Configuration* config_instance = nullptr;
static Dispatcher mainDispatcher;
static struct ModuleParent tactility_module_parent {
"tactility",
nullptr
};
ModuleParent& getModuleParent() {
return tactility_module_parent;
}
// region Default services
namespace service {
// Primary
@ -342,10 +333,9 @@ void run(const Configuration& config, Module* platformModule, Module* deviceModu
return;
}
// Module parent
check(module_parent_construct(&tactility_module_parent) == ERROR_NONE);
// hal-device-module
check(module_set_parent(&hal_device_module, &tactility_module_parent) == ERROR_NONE);
check(module_construct(&hal_device_module) == ERROR_NONE);
check(module_add(&hal_device_module) == ERROR_NONE);
check(module_start(&hal_device_module) == ERROR_NONE);
const hal::Configuration& hardware = *config.hardware;
@ -375,7 +365,8 @@ void run(const Configuration& config, Module* platformModule, Module* deviceModu
.task_affinity = getCpuAffinityConfiguration().graphics
#endif
});
check(module_set_parent(&lvgl_module, &tactility_module_parent) == ERROR_NONE);
check(module_construct(&lvgl_module) == ERROR_NONE);
check(module_add(&lvgl_module) == ERROR_NONE);
lvgl::start();
registerAndStartSecondaryServices();

49
TactilityC/CMakeLists.txt
View File

@ -1,32 +1,27 @@
cmake_minimum_required(VERSION 3.20)
include("${CMAKE_CURRENT_LIST_DIR}/../Buildscripts/module.cmake")
list(APPEND REQUIRES_LIST
lvgl
)
list(APPEND PRIV_REQUIRES_LIST
Tactility
TactilityCore
TactilityKernel
)
if (DEFINED ENV{ESP_IDF_VERSION})
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
list(APPEND PRIV_REQUIRES_LIST elf_loader)
endif ()
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
PRIV_INCLUDE_DIRS "Private/"
REQUIRES lvgl
PRIV_REQUIRES Tactility TactilityCore elf_loader TactilityKernel
)
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_compile_options(${COMPONENT_LIB} PUBLIC -Wno-unused-variable)
endif()
else()
file(GLOB_RECURSE SOURCES "Source/*.c**")
add_library(TactilityC OBJECT)
target_sources(TactilityC PRIVATE ${SOURCES})
include_directories(TactilityC PRIVATE Private/)
target_include_directories(TactilityC PUBLIC Include/)
target_link_libraries(TactilityC
PRIVATE Tactility
PRIVATE TactilityCore
PRIVATE TactilityKernel
PUBLIC lvgl
)
endif()
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
tactility_add_module(TactilityC
SRCS ${SOURCE_FILES}
INCLUDE_DIRS Include/
PRIV_INCLUDE_DIRS Private/
REQUIRES ${REQUIRES_LIST}
PRIV_REQUIRES ${PRIV_REQUIRES_LIST}
)

4
TactilityC/Source/tt_init.cpp
View File

@ -51,7 +51,6 @@
#include <Tactility/Tactility.h>
bool module_parent_resolve_symbol(ModuleParent* pParent, const char* name, uintptr_t* pInt);
extern "C" {
extern double __floatsidf(int x);
@ -375,9 +374,8 @@ uintptr_t tt_symbol_resolver(const char* symbolName) {
}
}
auto& module_parent = tt::getModuleParent();
uintptr_t symbol_address;
if (module_parent_resolve_symbol(&module_parent, symbolName, &symbol_address)) {
if (module_resolve_symbol_global(symbolName, &symbol_address)) {
return symbol_address;
}

44
TactilityCore/CMakeLists.txt
View File

@ -1,31 +1,23 @@
cmake_minimum_required(VERSION 3.20)
include("${CMAKE_CURRENT_LIST_DIR}/../Buildscripts/module.cmake")
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
list(APPEND REQUIRES_LIST
TactilityFreeRtos
TactilityKernel
mbedtls
)
if (DEFINED ENV{ESP_IDF_VERSION})
file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
idf_component_register(
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
REQUIRES TactilityFreeRtos TactilityKernel mbedtls nvs_flash esp_rom
list(APPEND REQUIRES_LIST
nvs_flash esp_rom
)
endif ()
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_compile_options(${COMPONENT_LIB} PUBLIC -Wno-unused-variable)
endif()
else()
file(GLOB_RECURSE SOURCES "Source/*.c*")
add_library(TactilityCore OBJECT)
target_sources(TactilityCore
PRIVATE ${SOURCES}
)
target_include_directories(TactilityCore PUBLIC Include/)
target_link_libraries(TactilityCore PUBLIC
TactilityFreeRtos
TactilityKernel
mbedtls
)
endif()
tactility_add_module(TactilityCore
SRCS ${SOURCE_FILES}
INCLUDE_DIRS "Include/"
REQUIRES ${REQUIRES_LIST}
)

58
TactilityCore/Include/Tactility/Logger.h
View File

@ -1,72 +1,70 @@
#pragma once
#include "LoggerAdapter.h"
#include "LoggerSettings.h"
#ifdef ESP_PLATFORM
#include "LoggerAdapterEsp.h"
#else
#include "LoggerAdapterGeneric.h"
#endif
#include <tactility/log.h>
#include <format>
namespace tt {
#ifdef ESP_PLATFORM
static LoggerAdapter defaultLoggerAdapter = espLoggerAdapter;
#else
static LoggerAdapter defaultLoggerAdapter = genericLoggerAdapter;
#endif
class Logger {
const char* tag;
LogLevel level = LOG_LEVEL_INFO;
public:
explicit Logger(const char* tag) : tag(tag) {}
template <typename... Args>
void log(LogLevel level, std::format_string<Args...> format, Args&&... args) const {
std::string message = std::format(format, std::forward<Args>(args)...);
defaultLoggerAdapter(level, tag, message.c_str());
}
template <typename... Args>
void verbose(std::format_string<Args...> format, Args&&... args) const {
log(LogLevel::Verbose, format, std::forward<Args>(args)...);
std::string message = std::format(format, std::forward<Args>(args)...);
LOG_V(tag, "%s", message.c_str());
}
template <typename... Args>
void debug(std::format_string<Args...> format, Args&&... args) const {
log(LogLevel::Debug, format, std::forward<Args>(args)...);
std::string message = std::format(format, std::forward<Args>(args)...);
LOG_D(tag, "%s", message.c_str());
}
template <typename... Args>
void info(std::format_string<Args...> format, Args&&... args) const {
log(LogLevel::Info, format, std::forward<Args>(args)...);
std::string message = std::format(format, std::forward<Args>(args)...);
LOG_I(tag, "%s", message.c_str());
}
template <typename... Args>
void warn(std::format_string<Args...> format, Args&&... args) const {
log(LogLevel::Warning, format, std::forward<Args>(args)...);
std::string message = std::format(format, std::forward<Args>(args)...);
LOG_W(tag, "%s", message.c_str());
}
template <typename... Args>
void error(std::format_string<Args...> format, Args&&... args) const {
log(LogLevel::Error, format, std::forward<Args>(args)...);
std::string message = std::format(format, std::forward<Args>(args)...);
LOG_E(tag, "%s", message.c_str());
}
bool isLoggingVerbose() const { return LogLevel::Verbose <= LOG_LEVEL; }
bool isLoggingVerbose() const {
return LOG_LEVEL_VERBOSE <= level;
}
bool isLoggingDebug() const { return LogLevel::Debug <= LOG_LEVEL; }
bool isLoggingDebug() const {
return LOG_LEVEL_DEBUG <= level;
}
bool isLoggingInfo() const { return LogLevel::Info <= LOG_LEVEL; }
bool isLoggingInfo() const {
return LOG_LEVEL_INFO <= level;
}
bool isLoggingWarning() const { return LogLevel::Warning <= LOG_LEVEL; }
bool isLoggingWarning() const {
return LOG_LEVEL_WARNING <= level;
}
bool isLoggingError() const { return LogLevel::Error <= LOG_LEVEL; }
bool isLoggingError() const {
return LOG_LEVEL_ERROR <= level;
}
};
}

10
TactilityCore/Include/Tactility/LoggerAdapter.h
View File

@ -1,10 +0,0 @@
#pragma once
#include "LoggerCommon.h"
#include <functional>
namespace tt {
typedef std::function<void(LogLevel level, const char* tag, const char* message)> LoggerAdapter;
}

35
TactilityCore/Include/Tactility/LoggerAdapterEsp.h
View File

@ -1,35 +0,0 @@
#pragma once
#include "LoggerAdapter.h"
#include "LoggerAdapterShared.h"
#include <esp_log.h>
#include <sstream>
namespace tt {
inline esp_log_level_t toEspLogLevel(LogLevel level) {
switch (level) {
case LogLevel::Error:
return ESP_LOG_ERROR;
case LogLevel::Warning:
return ESP_LOG_WARN;
case LogLevel::Info:
return ESP_LOG_INFO;
case LogLevel::Debug:
return ESP_LOG_DEBUG;
case LogLevel::Verbose:
default:
return ESP_LOG_VERBOSE;
}
}
static const LoggerAdapter espLoggerAdapter = [](LogLevel level, const char* tag, const char* message) {
constexpr auto COLOR_RESET = "\033[0m";
constexpr auto COLOR_GREY = "\033[37m";
std::stringstream buffer;
buffer << COLOR_GREY << esp_log_timestamp() << ' ' << toTagColour(level) << toPrefix(level) << COLOR_GREY << " [" << COLOR_RESET << tag << COLOR_GREY << "] " << toMessageColour(level) << message << COLOR_RESET << std::endl;
esp_log_write(toEspLogLevel(level), tag, "%s", buffer.str().c_str());
};
}

35
TactilityCore/Include/Tactility/LoggerAdapterGeneric.h
View File

@ -1,35 +0,0 @@
#pragma once
#include "LoggerAdapter.h"
#include "LoggerAdapterShared.h"
#include <cstdint>
#include <mutex>
#include <sstream>
#include <sys/time.h>
namespace tt {
static uint64_t getLogTimestamp() {
static uint64_t base = 0U;
static std::once_flag init_flag;
std::call_once(init_flag, []() {
timeval time {};
gettimeofday(&time, nullptr);
base = ((uint64_t)time.tv_sec * 1000U) + (time.tv_usec / 1000U);
});
timeval time {};
gettimeofday(&time, nullptr);
uint64_t now = ((uint64_t)time.tv_sec * 1000U) + (time.tv_usec / 1000U);
return now - base;
}
static const LoggerAdapter genericLoggerAdapter = [](LogLevel level, const char* tag, const char* message) {
constexpr auto COLOR_RESET = "\033[0m";
constexpr auto COLOR_GREY = "\033[37m";
std::stringstream buffer;
buffer << COLOR_GREY << getLogTimestamp() << ' ' << toTagColour(level) << toPrefix(level) << COLOR_GREY << " [" << COLOR_RESET << tag << COLOR_GREY << "] " << toMessageColour(level) << message << COLOR_RESET << std::endl;
printf("%s", buffer.str().c_str());
};
}

58
TactilityCore/Include/Tactility/LoggerAdapterShared.h
View File

@ -1,58 +0,0 @@
#pragma once
#include "LoggerCommon.h"
namespace tt {
inline const char* toTagColour(LogLevel level) {
using enum LogLevel;
switch (level) {
case Error:
return "\033[1;31m";
case Warning:
return "\033[1;33m";
case Info:
return "\033[32m";
case Debug:
return "\033[36m";
case Verbose:
return "\033[37m";
default:
return "";
}
}
inline const char* toMessageColour(LogLevel level) {
using enum LogLevel;
switch (level) {
case Error:
return "\033[1;31m";
case Warning:
return "\033[1;33m";
case Info:
case Debug:
case Verbose:
return "\033[0m";
default:
return "";
}
}
inline char toPrefix(LogLevel level) {
using enum LogLevel;
switch (level) {
case Error:
return 'E';
case Warning:
return 'W';
case Info:
return 'I';
case Debug:
return 'D';
case Verbose:
default:
return 'V';
}
}
}

14
TactilityCore/Include/Tactility/LoggerCommon.h
View File

@ -1,14 +0,0 @@
#pragma once
namespace tt {
/** Used for log output filtering */
enum class LogLevel : int {
Error, /*!< Critical errors, software module can not recover on its own */
Warning, /*!< Error conditions from which recovery measures have been taken */
Info, /*!< Information messages which describe normal flow of events */
Debug, /*!< Extra information which is not necessary for normal use (values, pointers, sizes, etc). */
Verbose /*!< Bigger chunks of debugging information, or frequent messages which can potentially flood the output. */
};
}

9
TactilityCore/Include/Tactility/LoggerSettings.h
View File

@ -1,9 +0,0 @@
#pragma once
#include "LoggerCommon.h"
namespace tt {
constexpr auto LOG_LEVEL = LogLevel::Info;
}

2
TactilityFreeRtos/CMakeLists.txt
View File

@ -18,4 +18,4 @@ else()
target_link_libraries(TactilityFreeRtos
INTERFACE freertos_kernel
)
endif()
endif()

28
TactilityKernel/CMakeLists.txt
View File

@ -1,20 +1,20 @@
cmake_minimum_required(VERSION 3.20)
file(GLOB_RECURSE SOURCES "Source/*.c**")
include("${CMAKE_CURRENT_LIST_DIR}/../Buildscripts/module.cmake")
file(GLOB_RECURSE SOURCE_FILES "Source/*.c**")
list(APPEND REQUIRES_LIST)
if (DEFINED ENV{ESP_IDF_VERSION})
idf_component_register(
SRCS ${SOURCES}
INCLUDE_DIRS "Include/"
# TODO move the related logic for esp_time in Tactility/time.h into the Platform/ subproject
REQUIRES esp_timer
)
# TODO move the related logic for esp_time in Tactility/time.h into the Platform/ subproject
list(APPEND REQUIRES_LIST esp_timer)
else ()
add_library(TactilityKernel OBJECT ${SOURCES})
target_include_directories(TactilityKernel PUBLIC Include/)
target_link_libraries(TactilityKernel PUBLIC freertos_kernel)
list(APPEND REQUIRES_LIST freertos_kernel)
endif ()
tactility_add_module(TactilityKernel
SRCS ${SOURCE_FILES}
INCLUDE_DIRS Include/
REQUIRES ${REQUIRES_LIST}
)

31
TactilityKernel/Include/tactility/log.h
View File

@ -10,25 +10,32 @@
extern "C" {
#endif
#define LOG_TAG(x) "\033[37m"#x"\033[0m"
/** Used for log output filtering */
enum LogLevel {
LOG_LEVEL_ERROR, /*!< Critical errors, software module can not recover on its own */
LOG_LEVEL_WARNING, /*!< Error conditions from which recovery measures have been taken */
LOG_LEVEL_INFO, /*!< Information messages which describe normal flow of events */
LOG_LEVEL_DEBUG, /*!< Extra information which is not necessary for normal use (values, pointers, sizes, etc). */
LOG_LEVEL_VERBOSE /*!< Bigger chunks of debugging information, or frequent messages which can potentially flood the output. */
};
#ifndef ESP_PLATFORM
void log_generic(const char* tag, const char* format, ...);
void log_generic(enum LogLevel level, const char* tag, const char* format, ...);
#define LOG_E(x, ...) log_generic(x, ##__VA_ARGS__)
#define LOG_W(x, ...) log_generic(x, ##__VA_ARGS__)
#define LOG_I(x, ...) log_generic(x, ##__VA_ARGS__)
#define LOG_D(x, ...) log_generic(x, ##__VA_ARGS__)
#define LOG_V(x, ...) log_generic(x, ##__VA_ARGS__)
#define LOG_E(tag, ...) log_generic(LOG_LEVEL_ERROR, tag, ##__VA_ARGS__)
#define LOG_W(tag, ...) log_generic(LOG_LEVEL_WARNING, tag, ##__VA_ARGS__)
#define LOG_I(tag, ...) log_generic(LOG_LEVEL_INFO, tag, ##__VA_ARGS__)
#define LOG_D(tag, ...) log_generic(LOG_LEVEL_DEBUG, tag, ##__VA_ARGS__)
#define LOG_V(tag, ...) log_generic(LOG_LEVEL_VERBOSE, tag, ##__VA_ARGS__)
#else
#define LOG_E(x, ...) ESP_LOGE(x, ##__VA_ARGS__)
#define LOG_W(x, ...) ESP_LOGW(x, ##__VA_ARGS__)
#define LOG_I(x, ...) ESP_LOGI(x, ##__VA_ARGS__)
#define LOG_D(x, ...) ESP_LOGD(x, ##__VA_ARGS__)
#define LOG_V(x, ...) ESP_LOGV(x, ##__VA_ARGS__)
#define LOG_E(tag, ...) ESP_LOGE(tag, ##__VA_ARGS__)
#define LOG_W(tag, ...) ESP_LOGW(tag, ##__VA_ARGS__)
#define LOG_I(tag, ...) ESP_LOGI(tag, ##__VA_ARGS__)
#define LOG_D(tag, ...) ESP_LOGD(tag, ##__VA_ARGS__)
#define LOG_V(tag, ...) ESP_LOGV(tag, ##__VA_ARGS__)
#endif

74
TactilityKernel/Include/tactility/module.h
View File

@ -6,15 +6,17 @@
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#define MODULE_SYMBOL_TERMINATOR { nullptr, nullptr }
#else
#define MODULE_SYMBOL_TERMINATOR { NULL, NULL }
#endif
struct ModuleParent;
struct ModuleParentPrivate;
#define MODULE_SYMBOL_TERMINATOR { NULL, NULL }
#define DEFINE_MODULE_SYMBOL(symbol) { #symbol, (void*)&symbol }
#ifdef __cplusplus
extern "C" {
#endif
/** A binary symbol like a function or a variable. */
struct ModuleSymbol {
/** The name of the symbol. */
@ -57,60 +59,45 @@ struct Module {
*/
const struct ModuleSymbol* symbols;
struct {
bool started;
struct ModuleParent* parent;
} internal;
};
/**
* A module parent is a collection of modules that can be loaded and unloaded at runtime.
* @brief Construct a module instance.
* @param module module instance to construct
* @return ERROR_NONE if successful
*/
struct ModuleParent {
/** The name of the parent module, for logging/debugging purposes */
const char* name;
struct ModuleParentPrivate* module_parent_private;
};
error_t module_construct(struct Module* module);
/**
* @brief Initialize the module parent.
* @warn This function does no validation on input or state.
* @param parent parent module
* @return ERROR_NONE if successful, ERROR_OUT_OF_MEMORY if allocation fails
* @brief Destruct a module instance.
* @param module module instance to destruct
* @return ERROR_NONE if successful
*/
error_t module_parent_construct(struct ModuleParent* parent);
error_t module_destruct(struct Module* module);
/**
* @brief Deinitialize the module parent. Must have no children when calling this.
* @warn This function does no validation on input.
* @param parent parent module
* @return ERROR_NONE if successful or ERROR_INVALID_STATE if the parent has children
* @brief Add a module to the system.
* @warning Only call this once. This function does not check if it was added before.
* @param module module to add
* @return ERROR_NONE if successful
*/
error_t module_parent_destruct(struct ModuleParent* parent);
error_t module_add(struct Module* module);
/**
* @brief Resolve a symbol from the module parent.
* @details This function iterates through all started modules in the parent and attempts to resolve the symbol.
* @param parent parent module
* @param symbol_name name of the symbol to resolve
* @param symbol_address pointer to store the address of the resolved symbol
* @return true if the symbol was found, false otherwise
* @brief Remove a module from the system.
* @param module module to remove
* @return ERROR_NONE if successful
*/
bool module_parent_resolve_symbol(struct ModuleParent* parent, const char* symbol_name, uintptr_t* symbol_address);
/**
* @brief Set the parent of the module.
* @warning must call before module_start()
* @param module module
* @param parent nullable parent module
* @return ERROR_NONE if successful, ERROR_INVALID_STATE if the module is already started
*/
error_t module_set_parent(struct Module* module, struct ModuleParent* parent);
error_t module_remove(struct Module* module);
/**
* @brief Start the module.
* @param module module
* @return ERROR_NONE if already started, ERROR_INVALID_STATE if the module doesn't have a parent, or otherwise it returns the result of the module's start function
* @return ERROR_NONE if already started, or otherwise it returns the result of the module's start function
*/
error_t module_start(struct Module* module);
@ -138,6 +125,15 @@ error_t module_stop(struct Module* module);
*/
bool module_resolve_symbol(struct Module* module, const char* symbol_name, uintptr_t* symbol_address);
/**
* @brief Resolve a symbol from any module
* @details This function iterates through all started modules in the parent and attempts to resolve the symbol.
* @param symbol_name name of the symbol to resolve
* @param symbol_address pointer to store the address of the resolved symbol
* @return true if the symbol was found, false otherwise
*/
bool module_resolve_symbol_global(const char* symbol_name, uintptr_t* symbol_address);
#ifdef __cplusplus
}
#endif

2
TactilityKernel/Source/concurrent/dispatcher.cpp
View File

@ -11,7 +11,7 @@
#include <tactility/log.h>
#include <atomic>
#define TAG LOG_TAG(Dispatcher)
#define TAG "Dispatcher"
static constexpr EventBits_t BACKPRESSURE_WARNING_COUNT = 100U;
static constexpr EventBits_t WAIT_FLAG = 1U;

2
TactilityKernel/Source/concurrent/thread.cpp
View File

@ -11,7 +11,7 @@
#include <string>
static const size_t LOCAL_STORAGE_SELF_POINTER_INDEX = 0;
static const char* TAG = LOG_TAG(Thread);
static const char* TAG = "Thread";
struct Thread {
TaskHandle_t taskHandle = nullptr;

2
TactilityKernel/Source/crash.cpp
View File

@ -2,7 +2,7 @@
#include <tactility/freertos/task.h>
#include <tactility/log.h>
static const auto* TAG = LOG_TAG(Kernel);
static const auto* TAG = "Kernel";
static void log_memory_info() {
#ifdef ESP_PLATFORM

2
TactilityKernel/Source/device.cpp
View File

@ -11,7 +11,7 @@
#include <sys/errno.h>
#include <vector>
#define TAG LOG_TAG(device)
#define TAG "device"
struct DevicePrivate {
std::vector<Device*> children;

22
TactilityKernel/Source/driver.cpp
View File

@ -10,7 +10,7 @@
#include <tactility/error.h>
#include <tactility/log.h>
#define TAG LOG_TAG(driver)
#define TAG "driver"
struct DriverPrivate {
Mutex mutex { 0 };
@ -30,21 +30,11 @@ struct DriverLedger {
std::vector<Driver*> drivers;
Mutex mutex { 0 };
DriverLedger() {
mutex_construct(&mutex);
}
DriverLedger() { mutex_construct(&mutex); }
~DriverLedger() { mutex_destruct(&mutex); }
~DriverLedger() {
mutex_destruct(&mutex);
}
void lock() {
mutex_lock(&mutex);
}
void unlock() {
mutex_unlock(&mutex);
}
void lock() { mutex_lock(&mutex); }
void unlock() { mutex_unlock(&mutex); }
};
static DriverLedger& get_ledger() {
@ -99,6 +89,8 @@ error_t driver_add(Driver* driver) {
error_t driver_remove(Driver* driver) {
LOG_I(TAG, "remove %s", driver->name);
if (driver->owner == nullptr) return ERROR_NOT_ALLOWED;
ledger.lock();
const auto iterator = std::ranges::find(ledger.drivers, driver);
if (iterator == ledger.drivers.end()) {

3
TactilityKernel/Source/drivers/root.cpp
View File

@ -12,8 +12,7 @@ Driver root_driver = {
.stop_device = nullptr,
.api = nullptr,
.device_type = nullptr,
.owner = nullptr,
.driver_private = nullptr
.owner = nullptr
};
}

36
TactilityKernel/Source/kernel_init.cpp
View File

@ -5,12 +5,7 @@
extern "C" {
#endif
#define TAG LOG_TAG(kernel)
struct ModuleParent kernel_module_parent = {
"kernel",
nullptr
};
#define TAG "kernel"
static error_t init_kernel_drivers() {
extern Driver root_driver;
@ -21,24 +16,37 @@ static error_t init_kernel_drivers() {
error_t kernel_init(struct Module* platform_module, struct Module* device_module, struct CompatibleDevice devicetree_devices[]) {
LOG_I(TAG, "init");
if (module_parent_construct(&kernel_module_parent) != ERROR_NONE) {
LOG_E(TAG, "init failed to create kernel module parent");
return ERROR_RESOURCE;
}
if (init_kernel_drivers() != ERROR_NONE) {
LOG_E(TAG, "init failed to init kernel drivers");
return ERROR_RESOURCE;
}
module_set_parent(platform_module, &kernel_module_parent);
if (module_construct(platform_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to construct platform module");
return ERROR_RESOURCE;
}
if (module_add(platform_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to add platform module");
return ERROR_RESOURCE;
}
if (module_start(platform_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to start platform module");
return ERROR_RESOURCE;
}
if (device_module != nullptr) {
module_set_parent(device_module, &kernel_module_parent);
if (module_construct(device_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to construct device module");
return ERROR_RESOURCE;
}
if (module_add(device_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to add device module");
return ERROR_RESOURCE;
}
if (module_start(device_module) != ERROR_NONE) {
LOG_E(TAG, "init failed to start device module");
return ERROR_RESOURCE;
@ -58,7 +66,7 @@ error_t kernel_init(struct Module* platform_module, struct Module* device_module
LOG_I(TAG, "init done");
return ERROR_NONE;
};
}
#ifdef __cplusplus
}

60
TactilityKernel/Source/log.cpp
View File

@ -4,17 +4,71 @@
#include <tactility/log.h>
#include <mutex>
#include <inttypes.h>
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <sys/time.h>
static const char* get_log_color(LogLevel level) {
using enum LogLevel;
switch (level) {
case LOG_LEVEL_ERROR:
return "\033[1;31m";
case LOG_LEVEL_WARNING:
return "\033[1;33m";
case LOG_LEVEL_INFO:
return "\033[32m";
case LOG_LEVEL_DEBUG:
return "\033[36m";
case LOG_LEVEL_VERBOSE:
return "\033[37m";
default:
return "";
}
}
static inline char get_log_prefix(LogLevel level) {
using enum LogLevel;
switch (level) {
case LOG_LEVEL_ERROR:
return 'E';
case LOG_LEVEL_WARNING:
return 'W';
case LOG_LEVEL_INFO:
return 'I';
case LOG_LEVEL_DEBUG:
return 'D';
case LOG_LEVEL_VERBOSE:
return 'V';
default:
return '?';
}
}
static uint64_t get_log_timestamp() {
static uint64_t base = 0U;
static std::once_flag init_flag;
std::call_once(init_flag, []() {
timeval time {};
gettimeofday(&time, nullptr);
base = ((uint64_t)time.tv_sec * 1000U) + (time.tv_usec / 1000U);
});
timeval time {};
gettimeofday(&time, nullptr);
uint64_t now = ((uint64_t)time.tv_sec * 1000U) + (time.tv_usec / 1000U);
return now - base;
}
extern "C" {
void log_generic(const char* tag, const char* format, ...) {
void log_generic(enum LogLevel level, const char* tag, const char* format, ...) {
va_list args;
va_start(args, format);
printf("%s ", tag);
printf("%s %c (%" PRIu64 ") %s ", get_log_color(level), get_log_prefix(level), get_log_timestamp(), tag);
vprintf(format, args);
printf("\n");
printf("\033[0m\n");
va_end(args);
}

101
TactilityKernel/Source/module.cpp
View File

@ -4,88 +4,40 @@
#include <tactility/concurrent/mutex.h>
#include <tactility/module.h>
#define TAG LOG_TAG(module)
#define TAG "module"
struct ModuleParentPrivate {
struct ModuleLedger {
std::vector<struct Module*> modules;
struct Mutex mutex = { 0 };
ModuleLedger() { mutex_construct(&mutex); }
~ModuleLedger() { mutex_destruct(&mutex); }
};
static ModuleLedger ledger;
extern "C" {
#pragma region module_parent
error_t module_parent_construct(struct ModuleParent* parent) {
parent->module_parent_private = new (std::nothrow) ModuleParentPrivate();
if (!parent->module_parent_private) return ERROR_OUT_OF_MEMORY;
auto* data = static_cast<ModuleParentPrivate*>(parent->module_parent_private);
mutex_construct(&data->mutex);
error_t module_construct(struct Module* module) {
module->internal.started = false;
return ERROR_NONE;
}
error_t module_parent_destruct(struct ModuleParent* parent) {
auto* data = static_cast<ModuleParentPrivate*>(parent->module_parent_private);
if (data == nullptr) return ERROR_NONE;
mutex_lock(&data->mutex);
if (!data->modules.empty()) {
mutex_unlock(&data->mutex);
return ERROR_INVALID_STATE;
}
mutex_unlock(&data->mutex);
mutex_destruct(&data->mutex);
delete data;
parent->module_parent_private = nullptr;
error_t module_destruct(struct Module* module) {
return ERROR_NONE;
}
bool module_parent_resolve_symbol(ModuleParent* parent, const char* symbol_name, uintptr_t* symbol_address) {
auto* data = static_cast<ModuleParentPrivate*>(parent->module_parent_private);
mutex_lock(&data->mutex);
for (auto* module : data->modules) {
if (!module_is_started(module))
continue;
if (module_resolve_symbol(module, symbol_name, symbol_address)) {
mutex_unlock(&data->mutex);
return true;
}
}
mutex_unlock(&data->mutex);
return false;
error_t module_add(struct Module* module) {
mutex_lock(&ledger.mutex);
ledger.modules.push_back(module);
mutex_unlock(&ledger.mutex);
return ERROR_NONE;
}
#pragma endregion
#pragma region module
error_t module_set_parent(struct Module* module, struct ModuleParent* parent) {
if (module->internal.started) return ERROR_INVALID_STATE;
if (module->internal.parent == parent) return ERROR_NONE;
// Remove from old parent
if (module->internal.parent && module->internal.parent->module_parent_private) {
auto* old_data = static_cast<ModuleParentPrivate*>(module->internal.parent->module_parent_private);
mutex_lock(&old_data->mutex);
auto it = std::find(old_data->modules.begin(), old_data->modules.end(), module);
if (it != old_data->modules.end()) {
old_data->modules.erase(it);
}
mutex_unlock(&old_data->mutex);
}
module->internal.parent = parent;
// Add to new parent
if (parent && parent->module_parent_private) {
auto* new_data = static_cast<ModuleParentPrivate*>(parent->module_parent_private);
mutex_lock(&new_data->mutex);
new_data->modules.push_back(module);
mutex_unlock(&new_data->mutex);
}
error_t module_remove(struct Module* module) {
mutex_lock(&ledger.mutex);
ledger.modules.erase(std::remove(ledger.modules.begin(), ledger.modules.end(), module), ledger.modules.end());
mutex_unlock(&ledger.mutex);
return ERROR_NONE;
}
@ -93,7 +45,6 @@ error_t module_start(struct Module* module) {
LOG_I(TAG, "start %s", module->name);
if (module->internal.started) return ERROR_NONE;
if (!module->internal.parent) return ERROR_INVALID_STATE;
error_t error = module->start();
module->internal.started = (error == ERROR_NONE);
@ -132,7 +83,19 @@ bool module_resolve_symbol(Module* module, const char* symbol_name, uintptr_t* s
return false;
}
#pragma endregion
bool module_resolve_symbol_global(const char* symbol_name, uintptr_t* symbol_address) {
mutex_lock(&ledger.mutex);
for (auto* module : ledger.modules) {
if (!module_is_started(module))
continue;
if (module_resolve_symbol(module, symbol_name, symbol_address)) {
mutex_unlock(&ledger.mutex);
return true;
}
}
mutex_unlock(&ledger.mutex);
return false;
}
}

16
Tests/Tactility/Main.cpp
View File

@ -7,21 +7,15 @@
#include <tactility/kernel_init.h>
#include <tactility/hal_device_module.h>
typedef struct {
int argc;
char** argv;
int result;
} TestTaskData;
extern "C" {
// From the relevant platform
extern struct Module platform_module;
}
struct ModuleParent tactility_tests_module_parent {
"tactility-tests",
nullptr
};
extern "C" struct Module platform_module;
void test_task(void* parameter) {
auto* data = (TestTaskData*)parameter;
@ -33,11 +27,7 @@ void test_task(void* parameter) {
// overrides
context.setOption("no-breaks", true); // don't break in the debugger when assertions fail
check(kernel_init(&platform_module, nullptr, nullptr) == ERROR_NONE);
// HAL compatibility module: it creates kernel driver wrappers for tt::hal::Device
check(module_parent_construct(&tactility_tests_module_parent) == ERROR_NONE);
check(module_set_parent(&hal_device_module, &tactility_tests_module_parent) == ERROR_NONE);
check(module_start(&hal_device_module) == ERROR_NONE);
check(kernel_init(&platform_module, &hal_device_module, nullptr) == ERROR_NONE);
data->result = context.run();

136
Tests/TactilityKernel/ModuleTest.cpp
View File

@ -1,6 +1,8 @@
#include "doctest.h"
#include <tactility/module.h>
static void symbol_test_function() { /* NO-OP */ }
static error_t test_start_result = ERROR_NONE;
static bool start_called = false;
static error_t test_start() {
@ -15,84 +17,40 @@ static error_t test_stop() {
return test_stop_result;
}
TEST_CASE("ModuleParent construction and destruction") {
struct ModuleParent parent = { "test_parent", nullptr };
TEST_CASE("Module construction and destruction") {
struct Module module = {
.name = "test",
.start = test_start,
.stop = test_stop,
.symbols = nullptr,
.internal = {.started = false}
};
// Test successful construction
CHECK_EQ(module_parent_construct(&parent), ERROR_NONE);
CHECK_NE(parent.module_parent_private, nullptr);
CHECK_EQ(module_construct(&module), ERROR_NONE);
CHECK_EQ(module.internal.started, false);
// Test successful destruction
CHECK_EQ(module_parent_destruct(&parent), ERROR_NONE);
CHECK_EQ(parent.module_parent_private, nullptr);
CHECK_EQ(module_destruct(&module), ERROR_NONE);
}
TEST_CASE("ModuleParent destruction with children") {
struct ModuleParent parent = { "parent", nullptr };
REQUIRE_EQ(module_parent_construct(&parent), ERROR_NONE);
TEST_CASE("Module registration") {
struct Module module = {
.name = "test",
.start = test_start,
.stop = test_stop,
.symbols = nullptr,
.internal = {.started = false, .parent = nullptr}
.internal = {.started = false}
};
REQUIRE_EQ(module_set_parent(&module, &parent), ERROR_NONE);
// module_add should succeed
CHECK_EQ(module_add(&module), ERROR_NONE);
// Should fail to destruct because it has a child
CHECK_EQ(module_parent_destruct(&parent), ERROR_INVALID_STATE);
CHECK_NE(parent.module_parent_private, nullptr);
// Remove child
REQUIRE_EQ(module_set_parent(&module, nullptr), ERROR_NONE);
// Now it should succeed
CHECK_EQ(module_parent_destruct(&parent), ERROR_NONE);
CHECK_EQ(parent.module_parent_private, nullptr);
}
TEST_CASE("Module parent management") {
struct ModuleParent parent1 = { "parent1", nullptr };
struct ModuleParent parent2 = { "parent2", nullptr };
REQUIRE_EQ(module_parent_construct(&parent1), ERROR_NONE);
REQUIRE_EQ(module_parent_construct(&parent2), ERROR_NONE);
struct Module module = {
.name = "test",
.start = test_start,
.stop = test_stop,
.symbols = nullptr,
.internal = {.started = false, .parent = nullptr}
};
// Set parent
CHECK_EQ(module_set_parent(&module, &parent1), ERROR_NONE);
CHECK_EQ(module.internal.parent, &parent1);
// Change parent
CHECK_EQ(module_set_parent(&module, &parent2), ERROR_NONE);
CHECK_EQ(module.internal.parent, &parent2);
// Clear parent
CHECK_EQ(module_set_parent(&module, nullptr), ERROR_NONE);
CHECK_EQ(module.internal.parent, nullptr);
// Set same parent (should be NOOP and return ERROR_NONE)
CHECK_EQ(module_set_parent(&module, &parent1), ERROR_NONE);
CHECK_EQ(module_set_parent(&module, &parent1), ERROR_NONE);
CHECK_EQ(module.internal.parent, &parent1);
CHECK_EQ(module_set_parent(&module, nullptr), ERROR_NONE);
CHECK_EQ(module_parent_destruct(&parent1), ERROR_NONE);
CHECK_EQ(module_parent_destruct(&parent2), ERROR_NONE);
// module_remove should succeed
CHECK_EQ(module_remove(&module), ERROR_NONE);
}
TEST_CASE("Module lifecycle") {
struct ModuleParent parent = { "parent", nullptr };
REQUIRE_EQ(module_parent_construct(&parent), ERROR_NONE);
start_called = false;
stop_called = false;
test_start_result = ERROR_NONE;
@ -103,48 +61,37 @@ TEST_CASE("Module lifecycle") {
.start = test_start,
.stop = test_stop,
.symbols = nullptr,
.internal = {.started = false, .parent = nullptr}
.internal = {.started = false}
};
// 1. Cannot start without parent
CHECK_EQ(module_start(&module), ERROR_INVALID_STATE);
CHECK_EQ(module_is_started(&module), false);
CHECK_EQ(start_called, false);
CHECK_EQ(module_set_parent(&module, &parent), ERROR_NONE);
// 2. Successful start
// 1. Successful start (no parent required anymore)
CHECK_EQ(module_start(&module), ERROR_NONE);
CHECK_EQ(module_is_started(&module), true);
CHECK_EQ(start_called, true);
// 3. Start when already started (should return ERROR_NONE)
// Start when already started (should return ERROR_NONE)
start_called = false;
CHECK_EQ(module_start(&module), ERROR_NONE);
CHECK_EQ(start_called, false); // start() function should NOT be called again
// 4. Cannot change parent while started
CHECK_EQ(module_set_parent(&module, nullptr), ERROR_INVALID_STATE);
// 5. Successful stop
// Stop successful
CHECK_EQ(module_stop(&module), ERROR_NONE);
CHECK_EQ(module_is_started(&module), false);
CHECK_EQ(stop_called, true);
// 6. Stop when already stopped (should return ERROR_NONE)
// Stop when already stopped (should return ERROR_NONE)
stop_called = false;
CHECK_EQ(module_stop(&module), ERROR_NONE);
CHECK_EQ(stop_called, false); // stop() function should NOT be called again
// 7. Test failed start
// Test failed start
test_start_result = ERROR_NOT_FOUND;
start_called = false;
CHECK_EQ(module_start(&module), ERROR_NOT_FOUND);
CHECK_EQ(module_is_started(&module), false);
CHECK_EQ(start_called, true);
// 8. Test failed stop
CHECK_EQ(module_set_parent(&module, &parent), ERROR_NONE);
// Test failed stop
test_start_result = ERROR_NONE;
CHECK_EQ(module_start(&module), ERROR_NONE);
@ -157,7 +104,32 @@ TEST_CASE("Module lifecycle") {
// Clean up: fix stop result so we can stop it
test_stop_result = ERROR_NONE;
CHECK_EQ(module_stop(&module), ERROR_NONE);
CHECK_EQ(module_set_parent(&module, nullptr), ERROR_NONE);
CHECK_EQ(module_parent_destruct(&parent), ERROR_NONE);
}
TEST_CASE("Global symbol resolution") {
static const struct ModuleSymbol test_symbols[] = {
DEFINE_MODULE_SYMBOL(symbol_test_function),
MODULE_SYMBOL_TERMINATOR
};
struct Module module = {
.name = "test_sym",
.start = test_start,
.stop = test_stop,
.symbols = test_symbols,
.internal = {.started = false}
};
uintptr_t addr;
// Should fail as it is not added or started
CHECK_EQ(module_resolve_symbol_global("symbol_test_function", &addr), false);
REQUIRE_EQ(module_add(&module), ERROR_NONE);
CHECK_EQ(module_resolve_symbol_global("symbol_test_function", &addr), false);
REQUIRE_EQ(module_start(&module), ERROR_NONE);
// Still fails as symbols are null
CHECK_EQ(module_resolve_symbol_global("symbol_test_function", &addr), true);
// Cleanup
CHECK_EQ(module_remove(&module), ERROR_NONE);
CHECK_EQ(module_destruct(&module), ERROR_NONE);
}