#ifndef _KE_TASK_H_ #define _KE_TASK_H_ /** **************************************************************************************** * @defgroup TASK Task and Process * @ingroup KERNEL * @brief Task management module. * * This module implements the functions used for managing tasks. * * @{ **************************************************************************************** */ /* * INCLUDE FILES **************************************************************************************** */ #include // standard integer #include // standard boolean #include "rwip_config.h" // stack configuration #include "compiler.h" // compiler defines, INLINE #include "ke_msg.h" // kernel message defines /* Default Message handler code to handle several message type in same handler. */ #define KE_MSG_DEFAULT_HANDLER (0xFFFF) /* Invalid task */ #define KE_TASK_INVALID (0xFFFF) /* Used to know if a message is not present in kernel queue */ #define KE_MSG_NOT_IN_QUEUE ((struct co_list_hdr *) 0xFFFFFFFF) /// Status of ke_task API functions enum KE_TASK_STATUS { KE_TASK_OK = 0, KE_TASK_FAIL, KE_TASK_UNKNOWN, KE_TASK_CAPA_EXCEEDED, KE_TASK_ALREADY_EXISTS, }; #define MSG_T(msg) ((ke_task_id_t)((msg) >> 8)) #define MSG_I(msg) ((msg) & ((1<<8)-1)) /// Format of a task message handler function typedef int (*ke_msg_func_t)(ke_msg_id_t const msgid, void const *param, ke_task_id_t const dest_id, ke_task_id_t const src_id); /// Macro for message handler function declaration or definition #define KE_MSG_HANDLER(msg_name, param_struct) __STATIC int msg_name##_handler(ke_msg_id_t const msgid, \ param_struct const *param, \ ke_task_id_t const dest_id, \ ke_task_id_t const src_id) #define KE_MSG_HANDLER_NO_STATIC(msg_name, param_struct) int msg_name##_handler(ke_msg_id_t const msgid, \ param_struct const *param, \ ke_task_id_t const dest_id, \ ke_task_id_t const src_id) /// Macro for message handlers table declaration or definition #define KE_MSG_HANDLER_TAB(task) __STATIC const struct ke_msg_handler task##_msg_handler_tab[] = /// Element of a message handler table. struct ke_msg_handler { /// Id of the handled message. ke_msg_id_t id; /// Pointer to the handler function for the msgid above. ke_msg_func_t func; }; /// Element of a state handler table. struct ke_state_handler { /// Pointer to the message handler table of this state. const struct ke_msg_handler *msg_table; /// Number of messages handled in this state. uint16_t msg_cnt; }; /// Task descriptor grouping all information required by the kernel for the scheduling. struct ke_task_desc { /// Pointer to the message handler table const struct ke_msg_handler* msg_handler_tab; /// Pointer to the state table (one element for each instance). ke_state_t* state; /// Maximum index of supported instances of the task. uint16_t idx_max; /// Number of messages handled uint16_t msg_cnt; }; /* * FUNCTION PROTOTYPES **************************************************************************************** */ /** **************************************************************************************** * @brief Initialize Kernel task module. **************************************************************************************** */ void ke_task_init(void); /** **************************************************************************************** * @brief Create a task. * * @param[in] task_type Task type. * @param[in] p_task_desc Pointer to task descriptor. * * @return Status **************************************************************************************** */ uint8_t ke_task_create(uint8_t task_type, struct ke_task_desc const * p_task_desc); /** **************************************************************************************** * @brief Delete a task. * * @param[in] task_type Task type. * * @return Status **************************************************************************************** */ uint8_t ke_task_delete(uint8_t task_type); /** **************************************************************************************** * @brief Retrieve the state of a task. * * @param[in] id Task id. * * @return Current state of the task **************************************************************************************** */ ke_state_t ke_state_get(ke_task_id_t const id); /** **************************************************************************************** * @brief Set the state of the task identified by its Task Id. * * In this function we also handle the SAVE service: when a task state changes we * try to activate all the messages currently saved in the save queue for the given * task identifier. * * @param[in] id Identifier of the task instance whose state is going to be modified * @param[in] state_id New State * **************************************************************************************** */ void ke_state_set(ke_task_id_t const id, ke_state_t const state_id); /** **************************************************************************************** * @brief Generic message handler to consume message without handling it in the task. * * @param[in] msgid Id of the message received (probably unused) * @param[in] param Pointer to the parameters of the message. * @param[in] dest_id TaskId of the receiving task. * @param[in] src_id TaskId of the sending task. * * @return KE_MSG_CONSUMED **************************************************************************************** */ int ke_msg_discard(ke_msg_id_t const msgid, void const *param, ke_task_id_t const dest_id, ke_task_id_t const src_id); /** **************************************************************************************** * @brief Generic message handler to consume message without handling it in the task. * * @param[in] msgid Id of the message received (probably unused) * @param[in] param Pointer to the parameters of the message. * @param[in] dest_id TaskId of the receiving task. * @param[in] src_id TaskId of the sending task. * * @return KE_MSG_CONSUMED **************************************************************************************** */ int ke_msg_save(ke_msg_id_t const msgid, void const *param, ke_task_id_t const dest_id, ke_task_id_t const src_id); /** **************************************************************************************** * @brief This function flushes all messages, currently pending in the kernel for a * specific task. * * @param[in] task The Task Identifier that shall be flushed. **************************************************************************************** */ void ke_task_msg_flush(ke_task_id_t task); /** **************************************************************************************** * @brief Check validity of a task. If task type or task instance does not exist, * return invalid task * * @param[in] task Task Identifier to check. * * @return Task identifier if valid, invalid identifier else. **************************************************************************************** */ ke_task_id_t ke_task_check(ke_task_id_t task); void ke_task_msg_retrieve(ke_task_id_t const id); /// @} TASK #endif // _KE_TASK_H_