进一步迭代优化统一管理
This commit is contained in:
冯佳
795
BSP/Src/bsp_module.c
Normal file
795
BSP/Src/bsp_module.c
Normal file
@ -0,0 +1,795 @@
|
||||
/* USER CODE BEGIN Header */
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file : bsp_module.c
|
||||
* @brief : Board support package module management source file
|
||||
******************************************************************************
|
||||
*/
|
||||
/* USER CODE END Header */
|
||||
|
||||
#include "bsp_module.h"
|
||||
#include <string.h>
|
||||
|
||||
/**
|
||||
* @brief Module manager instance
|
||||
*/
|
||||
static bsp_module_manager_t bsp_module_manager;
|
||||
|
||||
/**
|
||||
* @brief Initialize BSP module manager
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_manager_init(void) {
|
||||
/* Clear module manager */
|
||||
memset(&bsp_module_manager, 0, sizeof(bsp_module_manager));
|
||||
|
||||
/* Initialize module arrays */
|
||||
for (uint8_t i = 0; i < BSP_MODULE_TYPE_MAX; i++) {
|
||||
bsp_module_manager.modules[i] = NULL;
|
||||
}
|
||||
|
||||
bsp_module_manager.module_list = NULL;
|
||||
bsp_module_manager.module_count = 0;
|
||||
|
||||
return HAL_RET_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Register a BSP module
|
||||
* @param module: Pointer to module structure
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_register(bsp_module_t* module) {
|
||||
if (module == NULL) {
|
||||
return HAL_RET_INVALID_PARAM;
|
||||
}
|
||||
|
||||
if (module->config.type >= BSP_MODULE_TYPE_MAX) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
/* Check if module already exists */
|
||||
if (bsp_module_get(module->config.type, module->config.instance) != NULL) {
|
||||
return HAL_RESOURCE_LOCKED;
|
||||
}
|
||||
|
||||
/* Initialize module state */
|
||||
module->state = BSP_MODULE_STATE_UNINIT;
|
||||
module->next = NULL;
|
||||
module->prev = NULL;
|
||||
|
||||
/* Add module to the linked list */
|
||||
if (bsp_module_manager.module_list == NULL) {
|
||||
bsp_module_manager.module_list = module;
|
||||
} else {
|
||||
/* Insert module at the end of the list */
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current->next != NULL) {
|
||||
current = current->next;
|
||||
}
|
||||
current->next = module;
|
||||
module->prev = current;
|
||||
}
|
||||
|
||||
/* Add module to the type-specific list */
|
||||
if (bsp_module_manager.modules[module->config.type] == NULL) {
|
||||
bsp_module_manager.modules[module->config.type] = module;
|
||||
} else {
|
||||
/* Insert module at the end of the type-specific list */
|
||||
bsp_module_t* current = bsp_module_manager.modules[module->config.type];
|
||||
while (current->next != NULL && current->config.type == module->config.type) {
|
||||
current = current->next;
|
||||
}
|
||||
if (current->config.type == module->config.type) {
|
||||
current->next = module;
|
||||
module->prev = current;
|
||||
} else {
|
||||
/* Insert between current->prev and current */
|
||||
if (current->prev != NULL) {
|
||||
current->prev->next = module;
|
||||
} else {
|
||||
bsp_module_manager.modules[module->config.type] = module;
|
||||
}
|
||||
module->prev = current->prev;
|
||||
module->next = current;
|
||||
current->prev = module;
|
||||
}
|
||||
}
|
||||
|
||||
bsp_module_manager.module_count++;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Unregister a BSP module
|
||||
* @param module: Pointer to module structure
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_unregister(bsp_module_t* module) {
|
||||
if (module == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
/* Deinitialize module if it's initialized */
|
||||
if (module->state != BSP_MODULE_STATE_UNINIT) {
|
||||
if (module->ops.deinit != NULL) {
|
||||
module->ops.deinit();
|
||||
}
|
||||
module->state = BSP_MODULE_STATE_UNINIT;
|
||||
}
|
||||
|
||||
/* Remove module from linked list */
|
||||
if (module->prev != NULL) {
|
||||
module->prev->next = module->next;
|
||||
} else {
|
||||
/* Module is first in the list */
|
||||
bsp_module_manager.module_list = module->next;
|
||||
}
|
||||
|
||||
if (module->next != NULL) {
|
||||
module->next->prev = module->prev;
|
||||
}
|
||||
|
||||
/* Remove module from type-specific list */
|
||||
if (bsp_module_manager.modules[module->config.type] == module) {
|
||||
bsp_module_manager.modules[module->config.type] = module->next;
|
||||
}
|
||||
|
||||
/* Reset module pointers */
|
||||
module->next = NULL;
|
||||
module->prev = NULL;
|
||||
|
||||
bsp_module_manager.module_count--;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval Pointer to module structure, or NULL if not found
|
||||
*/
|
||||
bsp_module_t* bsp_module_get(bsp_module_type_t type, uint8_t instance) {
|
||||
if (type >= BSP_MODULE_TYPE_MAX) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bsp_module_t* current = bsp_module_manager.modules[type];
|
||||
while (current != NULL && current->config.type == type) {
|
||||
if (current->config.instance == instance) {
|
||||
return current;
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get all modules of a specific type
|
||||
* @param type: Module type
|
||||
* @retval Pointer to module list, or NULL if no modules found
|
||||
*/
|
||||
bsp_module_t* bsp_module_get_by_type(bsp_module_type_t type) {
|
||||
if (type >= BSP_MODULE_TYPE_MAX) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return bsp_module_manager.modules[type];
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get module by name
|
||||
* @param name: Module name
|
||||
* @retval Pointer to module structure, or NULL if not found
|
||||
*/
|
||||
bsp_module_t* bsp_module_get_by_name(const char* name) {
|
||||
if (name == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.name != NULL && strcmp(current->config.name, name) == 0) {
|
||||
return current;
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check if all dependencies of a module are satisfied
|
||||
* @param module: Pointer to module structure
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_check_dependencies(const bsp_module_t* module) {
|
||||
if (module == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
/* Check if dependencies are satisfied */
|
||||
if (module->config.dependencies == 0) {
|
||||
/* No dependencies */
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/* Check each dependency bit */
|
||||
for (uint8_t i = 0; i < BSP_MODULE_TYPE_MAX; i++) {
|
||||
if (module->config.dependencies & (1 << i)) {
|
||||
/* Check if dependency module exists and is initialized */
|
||||
bsp_module_t* dep_module = bsp_module_manager.modules[i];
|
||||
if (dep_module == NULL) {
|
||||
return HAL_RET_ERROR;
|
||||
}
|
||||
|
||||
/* Check if at least one instance is initialized */
|
||||
bsp_module_t* current = dep_module;
|
||||
uint8_t dep_found = 0;
|
||||
while (current != NULL && current->config.type == i) {
|
||||
if (current->state >= BSP_MODULE_STATE_INIT) {
|
||||
dep_found = 1;
|
||||
break;
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
if (!dep_found) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Initialize a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_init(bsp_module_type_t type, uint8_t instance) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is already initialized */
|
||||
if (module->state != BSP_MODULE_STATE_UNINIT) {
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/* Check dependencies */
|
||||
hal_ret_t status = bsp_module_check_dependencies(module);
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
|
||||
/* Initialize module */
|
||||
if (module->ops.init != NULL) {
|
||||
status = module->ops.init(module->config.config_data);
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
module->state = BSP_MODULE_STATE_INIT;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Deinitialize a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_deinit(bsp_module_type_t type, uint8_t instance) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is already uninitialized */
|
||||
if (module->state == BSP_MODULE_STATE_UNINIT) {
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/* Stop module if it's running */
|
||||
if (module->state == BSP_MODULE_STATE_RUNNING && module->ops.stop != NULL) {
|
||||
module->ops.stop();
|
||||
}
|
||||
|
||||
/* Deinitialize module */
|
||||
if (module->ops.deinit != NULL) {
|
||||
hal_ret_t status = module->ops.deinit();
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
module->state = BSP_MODULE_STATE_UNINIT;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Configure a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param config: Module configuration data
|
||||
* @param size: Module configuration size
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_configure(bsp_module_type_t type, uint8_t instance, void* config, size_t size) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is initialized */
|
||||
if (module->state < BSP_MODULE_STATE_INIT) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Configure module */
|
||||
if (module->ops.configure != NULL) {
|
||||
hal_ret_t status = module->ops.configure(config);
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
module->state = BSP_MODULE_STATE_CONFIGURED;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Start a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_start(bsp_module_type_t type, uint8_t instance) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is configured */
|
||||
if (module->state < BSP_MODULE_STATE_CONFIGURED) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Start module */
|
||||
if (module->ops.start != NULL) {
|
||||
hal_ret_t status = module->ops.start();
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
module->state = BSP_MODULE_STATE_RUNNING;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Stop a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_stop(bsp_module_type_t type, uint8_t instance) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is running */
|
||||
if (module->state != BSP_MODULE_STATE_RUNNING) {
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/* Stop module */
|
||||
if (module->ops.stop != NULL) {
|
||||
hal_ret_t status = module->ops.stop();
|
||||
if (status != HAL_OK) {
|
||||
module->state = BSP_MODULE_STATE_ERROR;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
module->state = BSP_MODULE_STATE_CONFIGURED;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reset a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_reset(bsp_module_type_t type, uint8_t instance) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Stop module if it's running */
|
||||
hal_ret_t status = bsp_module_stop(type, instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
/* Deinitialize module */
|
||||
status = bsp_module_deinit(type, instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
/* Reinitialize module */
|
||||
status = bsp_module_init(type, instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
/* Configure module */
|
||||
if (module->config.config_data != NULL) {
|
||||
status = bsp_module_configure(type, instance, module->config.config_data, module->config.config_size);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
/* Start module */
|
||||
status = bsp_module_start(type, instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get state of a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param state: Pointer to store module state
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_get_state(bsp_module_type_t type, uint8_t instance, bsp_module_state_t* state) {
|
||||
if (state == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
*state = BSP_MODULE_STATE_UNINIT;
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
*state = module->state;
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Control a specific BSP module
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param cmd: Control command
|
||||
* @param param: Control parameter
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_control(bsp_module_type_t type, uint8_t instance, uint32_t cmd, void* param) {
|
||||
/* Get module */
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Check if module is initialized */
|
||||
if (module->state < BSP_MODULE_STATE_INIT) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
/* Control module */
|
||||
if (module->ops.control != NULL) {
|
||||
return module->ops.control(cmd, param);
|
||||
}
|
||||
|
||||
return HAL_RET_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Initialize all registered BSP modules in priority order
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_init_all(void) {
|
||||
hal_ret_t status = HAL_RET_OK;
|
||||
|
||||
/* Initialize modules by priority */
|
||||
for (uint8_t priority = BSP_MODULE_PRIORITY_HIGHEST; priority <= BSP_MODULE_PRIORITY_LOWEST; priority++) {
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.priority == priority) {
|
||||
status = bsp_module_init(current->config.type, current->config.instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Deinitialize all registered BSP modules in reverse priority order
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_deinit_all(void) {
|
||||
hal_status_t status = HAL_OK;
|
||||
|
||||
/* Deinitialize modules by reverse priority */
|
||||
for (int8_t priority = BSP_MODULE_PRIORITY_LOWEST; priority >= BSP_MODULE_PRIORITY_HIGHEST; priority--) {
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.priority == priority) {
|
||||
status = bsp_module_deinit(current->config.type, current->config.instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Start all registered BSP modules in priority order
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_start_all(void) {
|
||||
hal_status_t status = HAL_OK;
|
||||
|
||||
/* Start modules by priority */
|
||||
for (uint8_t priority = BSP_MODULE_PRIORITY_HIGHEST; priority <= BSP_MODULE_PRIORITY_LOWEST; priority++) {
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.priority == priority && current->state >= BSP_MODULE_STATE_CONFIGURED) {
|
||||
status = bsp_module_start(current->config.type, current->config.instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Stop all registered BSP modules in reverse priority order
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_stop_all(void) {
|
||||
hal_status_t status = HAL_OK;
|
||||
|
||||
/* Stop modules by reverse priority */
|
||||
for (int8_t priority = BSP_MODULE_PRIORITY_LOWEST; priority >= BSP_MODULE_PRIORITY_HIGHEST; priority--) {
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.priority == priority && current->state == BSP_MODULE_STATE_RUNNING) {
|
||||
status = bsp_module_stop(current->config.type, current->config.instance);
|
||||
if (status != HAL_OK) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get total number of registered modules
|
||||
* @retval Number of registered modules
|
||||
*/
|
||||
uint32_t bsp_module_get_count(void) {
|
||||
return bsp_module_manager.module_count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get module manager instance
|
||||
* @retval Pointer to module manager structure
|
||||
*/
|
||||
bsp_module_manager_t* bsp_module_get_manager(void) {
|
||||
return &bsp_module_manager;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Register a module event callback
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param callback: Event callback function
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_register_event_callback(bsp_module_type_t type, uint8_t instance, bsp_module_event_callback_t callback) {
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
module->event_callback = callback;
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Trigger a module event
|
||||
* @param module: Pointer to module structure
|
||||
* @param event: Event to trigger
|
||||
* @param data: Event data
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_trigger_event(const bsp_module_t* module, uint32_t event, void* data) {
|
||||
if (module == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
// Check if module has an event callback registered
|
||||
if (module->event_callback != NULL) {
|
||||
return module->event_callback(module, event, data);
|
||||
}
|
||||
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Find modules by priority range
|
||||
* @param min_priority: Minimum priority
|
||||
* @param max_priority: Maximum priority
|
||||
* @param count: Pointer to store number of modules found
|
||||
* @retval Pointer to array of module pointers, or NULL if no modules found
|
||||
*/
|
||||
bsp_module_t** bsp_module_find_by_priority_range(bsp_module_priority_t min_priority, bsp_module_priority_t max_priority, uint32_t* count) {
|
||||
if (count == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// First pass: count matching modules
|
||||
uint32_t module_count = 0;
|
||||
bsp_module_t* current = bsp_module_manager.module_list;
|
||||
while (current != NULL) {
|
||||
if (current->config.priority >= min_priority && current->config.priority <= max_priority) {
|
||||
module_count++;
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
if (module_count == 0) {
|
||||
*count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Second pass: allocate and fill array
|
||||
bsp_module_t** modules = (bsp_module_t**)malloc(module_count * sizeof(bsp_module_t*));
|
||||
if (modules == NULL) {
|
||||
*count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
uint32_t index = 0;
|
||||
current = bsp_module_manager.module_list;
|
||||
while (current != NULL && index < module_count) {
|
||||
if (current->config.priority >= min_priority && current->config.priority <= max_priority) {
|
||||
modules[index++] = current;
|
||||
}
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
*count = module_count;
|
||||
return modules;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set module enable/disable state
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param enable: Enable flag
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_set_enable(bsp_module_type_t type, uint8_t instance, uint8_t enable) {
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
module->config.enable = enable;
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check if module is enabled
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param enable: Pointer to store enable state
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_is_enabled(bsp_module_type_t type, uint8_t instance, uint8_t* enable) {
|
||||
if (enable == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
*enable = 0;
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
*enable = module->config.enable;
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set module priority
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param priority: New priority
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_set_priority(bsp_module_type_t type, uint8_t instance, bsp_module_priority_t priority) {
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
module->config.priority = priority;
|
||||
return HAL_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get module priority
|
||||
* @param type: Module type
|
||||
* @param instance: Module instance
|
||||
* @param priority: Pointer to store priority
|
||||
* @retval HAL status code
|
||||
*/
|
||||
hal_ret_t bsp_module_get_priority(bsp_module_type_t type, uint8_t instance, bsp_module_priority_t* priority) {
|
||||
if (priority == NULL) {
|
||||
return HAL_INVALID_PARAM;
|
||||
}
|
||||
|
||||
bsp_module_t* module = bsp_module_get(type, instance);
|
||||
if (module == NULL) {
|
||||
*priority = BSP_MODULE_PRIORITY_MEDIUM;
|
||||
return HAL_ERROR;
|
||||
}
|
||||
|
||||
*priority = module->config.priority;
|
||||
return HAL_OK;
|
||||
}
|
||||
Reference in New Issue
Block a user