Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wwsmg1
rt-thread
提交
4962dc94
R
rt-thread
项目概览
wwsmg1
/
rt-thread
与 Fork 源项目一致
Fork自
RT-Thread / rt-thread
通知
1
Star
1
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
rt-thread
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
未验证
提交
4962dc94
编写于
7月 09, 2021
作者:
G
guo
提交者:
GitHub
7月 09, 2021
浏览文件
操作
浏览文件
下载
差异文件
Merge pull request #4859 from KyleChenjh/ipc_comment
[comment] Optimize the comment for ipc
上级
f8cf8341
9f3e349f
变更
1
显示空白变更内容
内联
并排
Showing
1 changed file
with
848 addition
and
231 deletion
+848
-231
src/ipc.c
src/ipc.c
+848
-231
未找到文件。
src/ipc.c
浏览文件 @
4962dc94
...
...
@@ -57,11 +57,16 @@ extern void (*rt_object_put_hook)(struct rt_object *object);
/**@{*/
/**
*
This function will initialize an IPC object
*
@brief This function will initialize an IPC object, such as semaphore, mutex, messagequeue and mailbox.
*
* @
param ipc the IPC object
* @
note Executing this function will complete an initialization of the suspend thread list of the ipc object.
*
* @return the operation status, RT_EOK on successful
* @param ipc is a pointer to the IPC object.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* When the return value is any other values, it means the initialization failed.
*
* @warning This function can be called from all IPC initialization and creation.
*/
rt_inline
rt_err_t
rt_ipc_object_init
(
struct
rt_ipc_object
*
ipc
)
{
...
...
@@ -71,16 +76,35 @@ rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc)
return
RT_EOK
;
}
/**
* This function will suspend a thread to a specified list. IPC object or some
* double-queue object (mailbox etc.) contains this kind of list.
* @brief This function will suspend a thread to a IPC object list.
*
* @param list is a pointer to a suspended thread list of the IPC object.
*
* @param thread is a pointer to the thread object to be suspended.
*
* @param flag is a flag for the thread object to be suspended. It determines how the thread is suspended.
* The flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to use
* RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this semaphore will become non-real-time threads.
*
* @param list the IPC suspended thread list
* @param thread the thread object to be suspended
* @param flag the IPC object flag,
* which shall be RT_IPC_FLAG_FIFO/RT_IPC_FLAG_PRIO.
* @return Return the operation status. When the return value is RT_EOK, the function is successfully executed.
* When the return value is any other values, it means the initialization failed.
*
* @return the operation status, RT_EOK on successful
* @warning This function can ONLY be called in the thread context, you can use RT_DEBUG_IN_THREAD_CONTEXT to
* check the context.
* In addition, this function is generally called by the following functions:
* rt_sem_take(), rt_mutex_take(), rt_event_recv(), rt_mb_send_wait(),
* rt_mb_recv(), rt_mq_recv(), rt_mq_send_wait()
*/
rt_inline
rt_err_t
rt_ipc_list_suspend
(
rt_list_t
*
list
,
struct
rt_thread
*
thread
,
...
...
@@ -131,14 +155,25 @@ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list,
return
RT_EOK
;
}
/**
* This function will resume the first thread in the list of a IPC object:
* - remove the thread from suspend queue of IPC object
* - put the thread into system ready queue
* @brief This function will resume a thread.
*
* @note This function will resume the first thread in the list of a IPC object.
* 1. remove the thread from suspend queue of a IPC object.
* 2. put the thread into system ready queue.
*
* By contrast, the rt_ipc_list_resume_all() function will resume all suspended threads
* in the list of a IPC object.
*
* @param list is a pointer to a suspended thread list of the IPC object.
*
* @param list the thread list
* @return Return the operation status. When the return value is RT_EOK, the function is successfully executed.
* When the return value is any other values, it means this operation failed.
*
* @return the operation status, RT_EOK on successful
* @warning This function is generally called by the following functions:
* rt_sem_release(), rt_mutex_release(), rt_mb_send_wait(), rt_mq_send_wait(),
* rt_mb_urgent(), rt_mb_recv(), rt_mq_urgent(), rt_mq_recv(),
*/
rt_inline
rt_err_t
rt_ipc_list_resume
(
rt_list_t
*
list
)
{
...
...
@@ -155,13 +190,19 @@ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
return
RT_EOK
;
}
/**
* This function will resume all suspended threads in a list, including
* suspend list of IPC object and private list of mailbox etc.
* @brief This function will resume all suspended threads in the IPC object list,
* including the suspended list of IPC object, and private list of mailbox etc.
*
* @note This function will resume all threads in the IPC object list.
* By contrast, the rt_ipc_list_resume() function will resume a suspended thread in the list of a IPC object.
*
* @param list of the threads to resume
* @param list is a pointer to a suspended thread list of the IPC object.
*
* @return Return the operation status. When the return value is RT_EOK, the function is successfully executed.
* When the return value is any other values, it means this operation failed.
*
* @return the operation status, RT_EOK on successful
*/
rt_inline
rt_err_t
rt_ipc_list_resume_all
(
rt_list_t
*
list
)
{
...
...
@@ -193,17 +234,51 @@ rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list)
return
RT_EOK
;
}
/**@}*/
#ifdef RT_USING_SEMAPHORE
/**
* This function will initialize a semaphore and put it under control of
* resource management.
* @addtogroup semaphore
*/
/**@{*/
/**
* @brief This function will initialize a static semaphore object.
*
* @note For the static semaphore object, its memory space is allocated by the compiler during compiling,
* and shall placed on the read-write data segment or on the uninitialized data segment.
* By contrast, the rt_sem_create() function will allocate memory space automatically and initialize
* the semaphore.
*
* @see rt_sem_create()
*
* @param sem is a pointer to the semaphore to initialize. It is assumed that storage for the semaphore will be
* allocated in your application.
*
* @param sem the semaphore object
* @param name the name of semaphore
* @param value the initial value of semaphore
* @param flag the flag of semaphore
* @param name is a pointer to the name you would like to give the semaphore.
*
* @return the operation status, RT_EOK on successful
* @param value is the initial value for the semaphore.
* If used to share resources, you should initialize the value as the number of available resources.
* If used to signal the occurrence of an event, you should initialize the value as 0.
*
* @param flag is the semaphore flag, which determines the queuing way of how multiple threads wait
* when the semaphore is not available.
* The semaphore flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this semaphore will become non-real-time threads.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it represents the initialization failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_err_t
rt_sem_init
(
rt_sem_t
sem
,
const
char
*
name
,
...
...
@@ -229,14 +304,24 @@ rt_err_t rt_sem_init(rt_sem_t sem,
}
RTM_EXPORT
(
rt_sem_init
);
/**
* This function will detach a semaphore from resource management
* @brief This function will detach a static semaphore object.
*
* @note This function is used to detach a static semaphore object which is initialized by rt_sem_init() function.
* By contrast, the rt_sem_delete() function will delete a semaphore object.
* When the semaphore is successfully detached, it will resume all suspended threads in the semaphore list.
*
* @
param sem the semaphore object
* @
see rt_sem_delete()
*
* @
return the operation status, RT_EOK on successful
* @
param sem is a pointer to a semaphore object to be detached.
*
* @see rt_sem_delete
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it means that the semaphore detach failed.
*
* @warning This function can ONLY detach a static semaphore initialized by the rt_sem_init() function.
* If the semaphore is created by the rt_sem_create() function, you MUST NOT USE this function to detach it,
* ONLY USE the rt_sem_delete() function to complete the deletion.
*/
rt_err_t
rt_sem_detach
(
rt_sem_t
sem
)
{
...
...
@@ -257,15 +342,36 @@ RTM_EXPORT(rt_sem_detach);
#ifdef RT_USING_HEAP
/**
* This function will create a semaphore from system resource
* @brief Creating a semaphore object.
*
* @note For the semaphore object, its memory space is allocated automatically.
* By contrast, the rt_sem_init() function will initialize a static semaphore object.
*
* @see rt_sem_init()
*
* @param name is a pointer to the name you would like to give the semaphore.
*
* @param value is the initial value for the semaphore.
* If used to share resources, you should initialize the value as the number of available resources.
* If used to signal the occurrence of an event, you should initialize the value as 0.
*
* @param
name the name of semaphore
*
@param value the initial value of semaphore
*
@param flag the flag of semaphore
* @param
flag is the semaphore flag, which determines the queuing way of how multiple threads wait
*
when the semaphore is not available.
*
The semaphore flag can be ONE of the following values:
*
*
@return the created semaphore, RT_NULL on error happen
*
RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* @see rt_sem_init
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this semaphore will become non-real-time threads.
*
* @return Return a pointer to the semaphore object. When the return value is RT_NULL, it means the creation failed.
*
* @warning This function can NOT be called in interrupt context. You can use macor RT_DEBUG_NOT_IN_INTERRUPT to check it.
*/
rt_sem_t
rt_sem_create
(
const
char
*
name
,
rt_uint32_t
value
,
rt_uint8_t
flag
)
{
...
...
@@ -292,14 +398,24 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_sem_create
);
/**
*
This function will delete a semaphore object and release the memory
*
@brief This function will delete a semaphore object and release the memory space.
*
* @param sem the semaphore object
* @note This function is used to delete a semaphore object which is created by the rt_sem_create() function.
* By contrast, the rt_sem_detach() function will detach a static semaphore object.
* When the semaphore is successfully deleted, it will resume all suspended threads in the semaphore list.
*
* @
return the error code
* @
see rt_sem_detach()
*
* @see rt_sem_detach
* @param sem is a pointer to a semaphore object to be deleted.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the semaphore detach failed.
*
* @warning This function can ONLY delete a semaphore initialized by the rt_sem_create() function.
* If the semaphore is initialized by the rt_sem_init() function, you MUST NOT USE this function to delete it,
* ONLY USE the rt_sem_detach() function to complete the detachment.
*/
rt_err_t
rt_sem_delete
(
rt_sem_t
sem
)
{
...
...
@@ -321,14 +437,29 @@ rt_err_t rt_sem_delete(rt_sem_t sem)
RTM_EXPORT
(
rt_sem_delete
);
#endif
/* RT_USING_HEAP */
/**
* This function will take a semaphore, if the semaphore is unavailable, the
* thread shall wait for a specified time.
* @brief This function will take a semaphore, if the semaphore is unavailable, the thread shall wait for
* the semaphore up to a specified time.
*
* @note When this function is called, the count value of the sem->value will decrease 1 until it is equal to 0.
* When the sem->value is 0, it means that the semaphore is unavailable. At this time, it will suspend the
* thread preparing to take the semaphore.
* On the contrary, the rt_sem_release() function will increase the count value of sem->value by 1 each time.
*
* @param sem the semaphore object
* @param time the waiting time
* @see rt_sem_trytake()
*
* @return the error code
* @param sem is a pointer to a semaphore object.
*
* @param time is a timeout period (unit: an OS tick). If the semaphore is unavailable, the thread will wait for
* the semaphore up to the amount of time specified by the argument.
* NOTE: Generally, we use the macro RT_WAITING_FOREVER to set this parameter, which means that when the
* semaphore is unavailable, the thread will be waitting forever.
*
* @return Return the operation status. ONLY When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the semaphore take failed.
*
* @warning This function can ONLY be called in the thread context. It MUST NOT BE called in interrupt context.
*/
rt_err_t
rt_sem_take
(
rt_sem_t
sem
,
rt_int32_t
time
)
{
...
...
@@ -418,12 +549,20 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
}
RTM_EXPORT
(
rt_sem_take
);
/**
*
This function will try to take a semaphore and immediately return
*
@brief This function will try to take a semaphore, if the semaphore is unavailable, the thread returns immediately.
*
* @param sem the semaphore object
* @note This function is very similar to the rt_sem_take() function, when the semaphore is not available,
* the rt_sem_trytake() function will return immediately without waiting for a timeout.
* In other words, rt_sem_trytake(sem) has the same effect as rt_sem_take(sem, 0).
*
* @return the error code
* @see rt_sem_take()
*
* @param sem is a pointer to a semaphore object.
*
* @return Return the operation status. ONLY When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the semaphore take failed.
*/
rt_err_t
rt_sem_trytake
(
rt_sem_t
sem
)
{
...
...
@@ -431,13 +570,18 @@ rt_err_t rt_sem_trytake(rt_sem_t sem)
}
RTM_EXPORT
(
rt_sem_trytake
);
/**
* This function will release a semaphore, if there are threads suspended on
* semaphore, it will be waked up.
* @brief This function will release a semaphore. If there is thread suspended on the semaphore, it will get resumed.
*
* @note If there are threads suspended on this semaphore, the first thread in the list of this semaphore object
* will be resumed, and a thread scheduling (rt_schedule) will be executed.
* If no threads are suspended on this semaphore, the count value sem->value of this semaphore will increase by 1.
*
* @param
sem the semaphore object
* @param
sem is a pointer to a semaphore object.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the semaphore release failed.
*/
rt_err_t
rt_sem_release
(
rt_sem_t
sem
)
{
...
...
@@ -490,14 +634,20 @@ rt_err_t rt_sem_release(rt_sem_t sem)
}
RTM_EXPORT
(
rt_sem_release
);
/**
* This function can get or set some extra attributions of a semaphore object.
* @brief This function will set some extra attributions of a semaphore object.
*
* @note Currently this function only supports the RT_IPC_CMD_RESET command to reset the semaphore.
*
* @param sem is a pointer to a semaphore object.
*
* @param cmd is a command word used to configure some attributions of the semaphore.
*
* @param sem the semaphore object
* @param cmd the execution command
* @param arg the execution argument
* @param arg is the argument of the function to execute the command.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that this function failed to execute.
*/
rt_err_t
rt_sem_control
(
rt_sem_t
sem
,
int
cmd
,
void
*
arg
)
{
...
...
@@ -533,18 +683,41 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
return
-
RT_ERROR
;
}
RTM_EXPORT
(
rt_sem_control
);
/**@}*/
#endif
/* RT_USING_SEMAPHORE */
#ifdef RT_USING_MUTEX
/**
* This function will initialize a mutex and put it under control of resource
* management.
* @addtogroup mutex
*/
/**@{*/
/**
* @brief Initialize a static mutex object.
*
* @note For the static mutex object, its memory space is allocated by the compiler during compiling,
* and shall placed on the read-write data segment or on the uninitialized data segment.
* By contrast, the rt_mutex_create() function will automatically allocate memory space
* and initialize the mutex.
*
* @param mutex the mutex object
* @param name the name of mutex
* @param flag the flag of mutex
* @see rt_mutex_create()
*
* @return the operation status, RT_EOK on successful
* @param mutex is a pointer to the mutex to initialize. It is assumed that storage for the mutex will be
* allocated in your application.
*
* @param name is a pointer to the name that given to the mutex.
*
* @param flag is the mutex flag, which determines the queuing way of how multiple threads wait
* when the mutex is not available.
* NOTE: The mutex flag can ONLY be RT_IPC_FLAG_PRIO. Using RT_IPC_FLAG_FIFO will seriously affect
* the real-time performance of the system.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it represents the initialization failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_err_t
rt_mutex_init
(
rt_mutex_t
mutex
,
const
char
*
name
,
rt_uint8_t
flag
)
{
...
...
@@ -571,14 +744,24 @@ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_mutex_init
);
/**
*
This function will detach a mutex from resource management
*
@brief This function will detach a static mutex object.
*
* @param mutex the mutex object
* @note This function is used to detach a static mutex object which is initialized by rt_mutex_init() function.
* By contrast, the rt_mutex_delete() function will delete a mutex object.
* When the mutex is successfully detached, it will resume all suspended threads in the mutex list.
*
* @
return the operation status, RT_EOK on successful
* @
see rt_mutex_delete()
*
* @see rt_mutex_delete
* @param mutex is a pointer to a mutex object to be detached.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it means that the mutex detach failed.
*
* @warning This function can ONLY detach a static mutex initialized by the rt_mutex_init() function.
* If the mutex is created by the rt_mutex_create() function, you MUST NOT USE this function to detach it,
* ONLY USE the rt_mutex_delete() function to complete the deletion.
*/
rt_err_t
rt_mutex_detach
(
rt_mutex_t
mutex
)
{
...
...
@@ -599,14 +782,23 @@ RTM_EXPORT(rt_mutex_detach);
#ifdef RT_USING_HEAP
/**
* This function will create a mutex from system resource
* @brief This function will create a mutex object.
*
* @note For the mutex object, its memory space is automatically allocated.
* By contrast, the rt_mutex_init() function will initialize a static mutex object.
*
* @see rt_mutex_init()
*
* @param name the name of mutex
* @param flag the flag of mutex
* @param name is a pointer to the name that given to the mutex.
*
* @return the created mutex, RT_NULL on error happen
* @param flag is the mutex flag, which determines the queuing way of how multiple threads wait
* when the mutex is not available.
* NOTE: The mutex flag can ONLY be RT_IPC_FLAG_PRIO. Using RT_IPC_FLAG_FIFO will seriously affect
* the real-time performance of the system.
*
* @see rt_mutex_init
* @return Return a pointer to the mutex object. When the return value is RT_NULL, it means the creation failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_mutex_t
rt_mutex_create
(
const
char
*
name
,
rt_uint8_t
flag
)
{
...
...
@@ -635,14 +827,24 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_mutex_create
);
/**
* This function will delete a mutex object and release the memory
* @brief This function will delete a mutex object and release this memory space.
*
* @note This function is used to delete a mutex object which is created by the rt_mutex_create() function.
* By contrast, the rt_mutex_detach() function will detach a static mutex object.
* When the mutex is successfully deleted, it will resume all suspended threads in the mutex list.
*
* @see rt_mutex_detach()
*
* @param
mutex the mutex object
* @param
mutex is a pointer to a mutex object to be deleted.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mutex detach failed.
*
* @see rt_mutex_detach
* @warning This function can ONLY delete a mutex initialized by the rt_mutex_create() function.
* If the mutex is initialized by the rt_mutex_init() function, you MUST NOT USE this function to delete it,
* ONLY USE the rt_mutex_detach() function to complete the detachment.
*/
rt_err_t
rt_mutex_delete
(
rt_mutex_t
mutex
)
{
...
...
@@ -664,14 +866,29 @@ rt_err_t rt_mutex_delete(rt_mutex_t mutex)
RTM_EXPORT
(
rt_mutex_delete
);
#endif
/* RT_USING_HEAP */
/**
* This function will take a mutex, if the mutex is unavailable, the
* thread shall wait for a specified time.
* @brief This function will take a mutex, if the mutex is unavailable, the thread shall wait for
* the mutex up to a specified time.
*
* @note When this function is called, the count value of the sem->value will decrease 1 until it is equal to 0.
* When the sem->value is 0, it means that the mutex is unavailable. At this time, it will suspend the
* thread preparing to take the mutex.
* On the contrary, the rt_sem_release() function will increase the count value of sem->value by 1 each time.
*
* @see rt_mutex_trytake()
*
* @param mutex is a pointer to a mutex object.
*
* @param mutex the mutex object
* @param time the waiting time
* @param time is a timeout period (unit: an OS tick). If the mutex is unavailable, the thread will wait for
* the mutex up to the amount of time specified by the argument.
* NOTE: Generally, we set this parameter to RT_WAITING_FOREVER, which means that when the mutex is unavailable,
* the thread will be waitting forever.
*
* @return the error code
* @return Return the operation status. ONLY When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mutex take failed.
*
* @warning This function can ONLY be called in the thread context. It MUST NOT BE called in interrupt context.
*/
rt_err_t
rt_mutex_take
(
rt_mutex_t
mutex
,
rt_int32_t
time
)
{
...
...
@@ -821,12 +1038,21 @@ __again:
}
RTM_EXPORT
(
rt_mutex_take
);
/**
* This function will try to take a mutex and immediately return
* @brief This function will try to take a mutex, if the mutex is unavailable, the thread returns immediately.
*
* @note This function is very similar to the rt_mutex_take() function, when the mutex is not available,
* except that rt_mutex_trytake() will return immediately without waiting for a timeout
* when the mutex is not available.
* In other words, rt_mutex_trytake(mutex) has the same effect as rt_mutex_take(mutex, 0).
*
* @see rt_mutex_take()
*
* @param
mutex the mutex object
* @param
mutex is a pointer to a mutex object.
*
* @return the error code
* @return Return the operation status. ONLY When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mutex take failed.
*/
rt_err_t
rt_mutex_trytake
(
rt_mutex_t
mutex
)
{
...
...
@@ -834,13 +1060,18 @@ rt_err_t rt_mutex_trytake(rt_mutex_t mutex)
}
RTM_EXPORT
(
rt_mutex_trytake
);
/**
* This function will release a mutex, if there are threads suspended on mutex,
* it will be waked up.
* @brief This function will release a mutex. If there is thread suspended on the mutex, the thread will be resumed.
*
* @note If there are threads suspended on this mutex, the first thread in the list of this mutex object
* will be resumed, and a thread scheduling (rt_schedule) will be executed.
* If no threads are suspended on this mutex, the count value mutex->value of this mutex will increase by 1.
*
* @param
mutex the mutex object
* @param
mutex is a pointer to a mutex object.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mutex release failed.
*/
rt_err_t
rt_mutex_release
(
rt_mutex_t
mutex
)
{
...
...
@@ -953,14 +1184,20 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
}
RTM_EXPORT
(
rt_mutex_release
);
/**
* This function can get or set some extra attributions of a mutex object.
* @brief This function will set some extra attributions of a mutex object.
*
* @note Currently this function does not implement the control function.
*
* @param mutex the mutex object
* @param cmd the execution command
* @param arg the execution argument
* @param mutex is a pointer to a mutex object.
*
* @return the error code
* @param cmd is a command word used to configure some attributions of the mutex.
*
* @param arg is the argument of the function to execute the command.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that this function failed to execute.
*/
rt_err_t
rt_mutex_control
(
rt_mutex_t
mutex
,
int
cmd
,
void
*
arg
)
{
...
...
@@ -971,18 +1208,54 @@ rt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg)
return
-
RT_ERROR
;
}
RTM_EXPORT
(
rt_mutex_control
);
/**@}*/
#endif
/* RT_USING_MUTEX */
#ifdef RT_USING_EVENT
/**
* This function will initialize an event and put it under control of resource
* management.
* @addtogroup event
*/
/**@{*/
/**
* @brief The function will initialize a static event object.
*
* @note For the static event object, its memory space is allocated by the compiler during compiling,
* and shall placed on the read-write data segment or on the uninitialized data segment.
* By contrast, the rt_event_create() function will allocate memory space automatically
* and initialize the event.
*
* @see rt_event_create()
*
* @param event is a pointer to the event to initialize. It is assumed that storage for the event
* will be allocated in your application.
*
* @param name is a pointer to the name that given to the event.
*
* @param value is the initial value for the event.
* If want to share resources, you should initialize the value as the number of available resources.
* If want to signal the occurrence of an event, you should initialize the value as 0.
*
* @param flag is the event flag, which determines the queuing way of how multiple threads wait
* when the event is not available.
* The event flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* @param event the event object
* @param name the name of event
* @param flag the flag of event
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* @return the operation status, RT_EOK on successful
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this event will become non-real-time threads.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it represents the initialization failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_err_t
rt_event_init
(
rt_event_t
event
,
const
char
*
name
,
rt_uint8_t
flag
)
{
...
...
@@ -1005,12 +1278,24 @@ rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_event_init
);
/**
* This function will detach an event object from resource management
* @brief This function will detach a static event object.
*
* @note This function is used to detach a static event object which is initialized by rt_event_init() function.
* By contrast, the rt_event_delete() function will delete an event object.
* When the event is successfully detached, it will resume all suspended threads in the event list.
*
* @
param event the event object
* @
see rt_event_delete()
*
* @return the operation status, RT_EOK on successful
* @param event is a pointer to an event object to be detached.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it means that the event detach failed.
*
* @warning This function can ONLY detach a static event initialized by the rt_event_init() function.
* If the event is created by the rt_event_create() function, you MUST NOT USE this function to detach it,
* ONLY USE the rt_event_delete() function to complete the deletion.
*/
rt_err_t
rt_event_detach
(
rt_event_t
event
)
{
...
...
@@ -1031,12 +1316,32 @@ RTM_EXPORT(rt_event_detach);
#ifdef RT_USING_HEAP
/**
* This function will create an event object from system resource
* @brief Creating an event object.
*
* @note For the event object, its memory space is allocated automatically.
* By contrast, the rt_event_init() function will initialize a static event object.
*
* @see rt_event_init()
*
* @param name the name of event
* @param flag the flag of event
* @param name is a pointer to the name that given to the event.
*
* @return the created event, RT_NULL on error happen
* @param flag is the event flag, which determines the queuing way of how multiple threads wait when the event
* is not available.
* The event flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this event will become non-real-time threads.
*
* @return Return a pointer to the event object. When the return value is RT_NULL, it means the creation failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_event_t
rt_event_create
(
const
char
*
name
,
rt_uint8_t
flag
)
{
...
...
@@ -1062,12 +1367,24 @@ rt_event_t rt_event_create(const char *name, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_event_create
);
/**
* This function will delete an event object and release the memory
* @brief This function will delete an event object and release the memory space.
*
* @note This function is used to delete an event object which is created by the rt_event_create() function.
* By contrast, the rt_event_detach() function will detach a static event object.
* When the event is successfully deleted, it will resume all suspended threads in the event list.
*
* @see rt_event_detach()
*
* @param
event the event object
* @param
event is a pointer to an event object to be deleted.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the event detach failed.
*
* @warning This function can ONLY delete an event initialized by the rt_event_create() function.
* If the event is initialized by the rt_event_init() function, you MUST NOT USE this function to delete it,
* ONLY USE the rt_event_detach() function to complete the detachment.
*/
rt_err_t
rt_event_delete
(
rt_event_t
event
)
{
...
...
@@ -1089,14 +1406,23 @@ rt_err_t rt_event_delete(rt_event_t event)
RTM_EXPORT
(
rt_event_delete
);
#endif
/* RT_USING_HEAP */
/**
* This function will send an event to the event object, if there are threads
* suspended on event object, it will be waked up.
* @brief This function will send an event to the event object.
* If there is a thread suspended on the event, the thread will be resumed.
*
* @note When using this function, you need to use the parameter (set) to specify the event flag of the event object,
* then the function will traverse the list of suspended threads waiting on the event object.
* If there is a thread suspended on the event, and the thread's event_info and the event flag of
* the current event object matches, the thread will be resumed.
*
* @param event is a pointer to the event object to be sent.
*
* @param
event the event object
*
@param set the event set
* @param
set is a flag that you will set for this event's flag.
*
You can set an event flag, or you can set multiple flags through OR logic operation.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the event detach failed.
*/
rt_err_t
rt_event_send
(
rt_event_t
event
,
rt_uint32_t
set
)
{
...
...
@@ -1190,18 +1516,38 @@ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set)
}
RTM_EXPORT
(
rt_event_send
);
/**
* This function will receive an event from event object, if the event is
* unavailable, the thread shall wait for a specified time.
* @brief This function will receive an event from event object. if the event is unavailable, the thread shall wait for
* the event up to a specified time.
*
* @note If there are threads suspended on this semaphore, the first thread in the list of this semaphore object
* will be resumed, and a thread scheduling (rt_schedule) will be executed.
* If no threads are suspended on this semaphore, the count value sem->value of this semaphore will increase by 1.
*
* @param event is a pointer to the event object to be received.
*
* @param set is a flag that you will set for this event's flag.
* You can set an event flag, or you can set multiple flags through OR logic operation.
*
* @param event the fast event object
* @param set the interested event set
* @param option the receive option, either RT_EVENT_FLAG_AND or
* RT_EVENT_FLAG_OR should be set.
* @param timeout the waiting time
* @param recved the received event, if you don't care, RT_NULL can be set.
* @param option is the option of this receiving event, it indicates how the receiving event is operated.
* The option can be one or more of the following values, When selecting multiple values,use logical OR to operate.
* (NOTE: RT_EVENT_FLAG_OR and RT_EVENT_FLAG_AND can only select one):
*
* @return the error code
*
* RT_EVENT_FLAG_OR The thread select to use logical OR to receive the event.
*
* RT_EVENT_FLAG_AND The thread select to use logical OR to receive the event.
*
* RT_EVENT_FLAG_CLEAR When the thread receives the corresponding event, the function
* determines whether to clear the event flag.
*
* @param timeout is a timeout period (unit: an OS tick).
*
* @param recved is a pointer to the received event. If you don't care about this value, you can use RT_NULL to set.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the semaphore release failed.
*/
rt_err_t
rt_event_recv
(
rt_event_t
event
,
rt_uint32_t
set
,
...
...
@@ -1325,14 +1671,20 @@ rt_err_t rt_event_recv(rt_event_t event,
}
RTM_EXPORT
(
rt_event_recv
);
/**
* This function can get or set some extra attributions of an event object.
* @brief This function will set some extra attributions of an event object.
*
* @note Currently this function only supports the RT_IPC_CMD_RESET command to reset the event.
*
* @param event is a pointer to an event object.
*
* @param event the event object
* @param cmd the execution command
* @param arg the execution argument
* @param cmd is a command word used to configure some attributions of the event.
*
* @return the error code
* @param arg is the argument of the function to execute the command.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that this function failed to execute.
*/
rt_err_t
rt_event_control
(
rt_event_t
event
,
int
cmd
,
void
*
arg
)
{
...
...
@@ -1364,20 +1716,55 @@ rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg)
return
-
RT_ERROR
;
}
RTM_EXPORT
(
rt_event_control
);
/**@}*/
#endif
/* RT_USING_EVENT */
#ifdef RT_USING_MAILBOX
/**
* This function will initialize a mailbox and put it under control of resource
* management.
* @addtogroup mailbox
*/
/**@{*/
/**
* @brief Initialize a static mailbox object.
*
* @param mb the mailbox object
* @param name the name of mailbox
* @param msgpool the begin address of buffer to save received mail
* @param size the size of mailbox
* @param flag the flag of mailbox
* @note For the static mailbox object, its memory space is allocated by the compiler during compiling,
* and shall placed on the read-write data segment or on the uninitialized data segment.
* By contrast, the rt_mb_create() function will allocate memory space automatically and initialize the mailbox.
*
* @return the operation status, RT_EOK on successful
* @see rt_mb_create()
*
* @param mb is a pointer to the mailbox to initialize.
* It is assumed that storage for the mailbox will be allocated in your application.
*
* @param name is a pointer to the name that given to the mailbox.
*
* @param msgpoll is a pointer to the starting address of the memory space you allocated for the mailbox in advance.
* In other words, msgpoll is a pointer to the mailbox buffer of the starting address.
*
* @param size is the maximum number of mails in the mailbox.
* For example, when the mailbox buffer capacity is N, size is N/4.
*
* @param flag is the mailbox flag, which determines the queuing way of how multiple threads wait
* when the mailbox is not available.
* The mailbox flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this mailbox will become non-real-time threads.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it represents the initialization failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_err_t
rt_mb_init
(
rt_mailbox_t
mb
,
const
char
*
name
,
...
...
@@ -1410,12 +1797,24 @@ rt_err_t rt_mb_init(rt_mailbox_t mb,
}
RTM_EXPORT
(
rt_mb_init
);
/**
* This function will detach a mailbox from resource management
* @brief This function will detach a static mailbox object.
*
* @note This function is used to detach a static mailbox object which is initialized by rt_mb_init() function.
* By contrast, the rt_mb_delete() function will delete a mailbox object.
* When the mailbox is successfully detached, it will resume all suspended threads in the mailbox list.
*
* @
param mb the mailbox object
* @
see rt_mb_delete()
*
* @return the operation status, RT_EOK on successful
* @param mb is a pointer to a mailbox object to be detached.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*
* @warning This function can ONLY detach a static mailbox initialized by the rt_mb_init() function.
* If the mailbox is created by the rt_mb_create() function, you MUST NOT USE this function to detach it,
* ONLY USE the rt_mb_delete() function to complete the deletion.
*/
rt_err_t
rt_mb_detach
(
rt_mailbox_t
mb
)
{
...
...
@@ -1438,13 +1837,35 @@ RTM_EXPORT(rt_mb_detach);
#ifdef RT_USING_HEAP
/**
* This function will create a mailbox object from system resource
* @brief Creating a mailbox object.
*
* @note For the mailbox object, its memory space is allocated automatically.
* By contrast, the rt_mb_init() function will initialize a static mailbox object.
*
* @see rt_mb_init()
*
* @param name the name of mailbox
* @param size the size of mailbox
* @param flag the flag of mailbox
* @param name is a pointer that given to the mailbox.
*
* @return the created mailbox, RT_NULL on error happen
* @param size is the maximum number of mails in the mailbox.
* For example, when mailbox buffer capacity is N, size is N/4.
*
* @param flag is the mailbox flag, which determines the queuing way of how multiple threads wait
* when the mailbox is not available.
* The mailbox flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this mailbox will become non-real-time threads.
*
* @return Return a pointer to the mailbox object. When the return value is RT_NULL, it means the creation failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_mailbox_t
rt_mb_create
(
const
char
*
name
,
rt_size_t
size
,
rt_uint8_t
flag
)
{
...
...
@@ -1484,12 +1905,24 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag)
}
RTM_EXPORT
(
rt_mb_create
);
/**
* This function will delete a mailbox object and release the memory
* @brief This function will delete a mailbox object and release the memory space.
*
* @note This function is used to delete a mailbox object which is created by the rt_mb_create() function.
* By contrast, the rt_mb_detach() function will detach a static mailbox object.
* When the mailbox is successfully deleted, it will resume all suspended threads in the mailbox list.
*
* @
param mb the mailbox object
* @
see rt_mb_detach()
*
* @return the error code
* @param mb is a pointer to a mailbox object to be deleted.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*
* @warning This function can only delete mailbox created by the rt_mb_create() function.
* If the mailbox is initialized by the rt_mb_init() function, you MUST NOT USE this function to delete it,
* ONLY USE the rt_mb_detach() function to complete the detachment.
*/
rt_err_t
rt_mb_delete
(
rt_mailbox_t
mb
)
{
...
...
@@ -1517,15 +1950,29 @@ rt_err_t rt_mb_delete(rt_mailbox_t mb)
RTM_EXPORT
(
rt_mb_delete
);
#endif
/* RT_USING_HEAP */
/**
* This function will send a mail to mailbox object. If the mailbox is full,
* current thread will be suspended until timeout.
* @brief This function will send an mail to the mailbox object. If there is a thread suspended on the mailbox,
* the thread will be resumed.
*
* @note When using this function to send a mail, if the mailbox if fully used, the current thread will
* wait for a timeout. If the set timeout time is reached and there is still no space available,
* the sending thread will be resumed and an error code will be returned.
* By contrast, the rt_mb_send() function will return an error code immediately without waiting time
* when the mailbox if fully used.
*
* @see rt_mb_send()
*
* @param mb is a pointer to the mailbox object to be sent.
*
* @param value is a value to the content of the mail you want to send.
*
* @param timeout is a timeout period (unit: an OS tick).
*
* @param mb the mailbox object
* @param value the mail
* @param timeout the waiting time
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*
* @
return the error code
* @
warning This function can be called in interrupt context and thread context.
*/
rt_err_t
rt_mb_send_wait
(
rt_mailbox_t
mb
,
rt_ubase_t
value
,
...
...
@@ -1657,15 +2104,23 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
}
RTM_EXPORT
(
rt_mb_send_wait
);
/**
* This function will send a mail to mailbox object, if there are threads
* suspended on mailbox object, it will be waked up. This function will return
* immediately, if you want blocking send, use rt_mb_send_wait instead.
* @brief This function will send an mail to the mailbox object. If there is a thread suspended on the mailbox,
* the thread will be resumed.
*
* @note When using this function to send a mail, if the mailbox is fully used, this function will return an error
* code immediately without waiting time.
* By contrast, the rt_mb_send_wait() function is set a timeout to wait for the mail to be sent.
*
* @see rt_mb_send_wait()
*
* @param mb is a pointer to the mailbox object to be sent.
*
* @param mb the mailbox object
* @param value the mail
* @param value is a value to the content of the mail you want to send.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*/
rt_err_t
rt_mb_send
(
rt_mailbox_t
mb
,
rt_ubase_t
value
)
{
...
...
@@ -1673,15 +2128,22 @@ rt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value)
}
RTM_EXPORT
(
rt_mb_send
);
/**
* This function will send an urgent mail to mailbox object, if there are threads
* suspended on mailbox object, it will be waked up. This function will return
* immediately.
* @brief This function will send an urgent mail to the mailbox object.
*
* @note This function is almost the same as the rt_mb_send() function. The only difference is that
* when sending an urgent mail, the mail will be placed at the head of the mail queue so that
* the recipient can receive the urgent mail first.
*
* @see rt_mb_send()
*
* @param mb is a pointer to the mailbox object to be sent.
*
* @param mb the mailbox object
* @param value the mail
* @param value is the content of the mail you want to send.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*/
rt_err_t
rt_mb_urgent
(
rt_mailbox_t
mb
,
rt_ubase_t
value
)
{
...
...
@@ -1738,15 +2200,24 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
}
RTM_EXPORT
(
rt_mb_urgent
);
/**
* This function will receive a mail from mailbox object, if there is no mail
* in mailbox object, the thread shall wait for a specified time.
* @brief This function will receive a mail from mailbox object, if there is no mail in mailbox object,
* the thread shall wait for a specified time.
*
* @note Only when there is mail in the mailbox, the receiving thread can get the mail immediately and
* return RT_EOK, otherwise the receiving thread will be suspended until the set timeout. If the mail
* is still not received within the specified time, it will return-RT_ETIMEOUT.
*
* @param mb is a pointer to the mailbox object to be received.
*
* @param value is a flag that you will set for this mailbox's flag.
* You can set an mailbox flag, or you can set multiple flags through OR logic operations.
*
* @param mb the mailbox object
* @param value the received mail will be saved in
* @param timeout the waiting time
* @param timeout is a timeout period (unit: an OS tick).
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox release failed.
*/
rt_err_t
rt_mb_recv
(
rt_mailbox_t
mb
,
rt_ubase_t
*
value
,
rt_int32_t
timeout
)
{
...
...
@@ -1879,14 +2350,20 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
}
RTM_EXPORT
(
rt_mb_recv
);
/**
* This function can get or set some extra attributions of a mailbox object.
* @brief This function will set some extra attributions of a mailbox object.
*
* @note Currently this function only supports the RT_IPC_CMD_RESET command to reset the mailbox.
*
* @param mb is a pointer to a mailbox object.
*
* @param cmd is a command used to configure some attributions of the mailbox.
*
* @param mb the mailbox object
* @param cmd the execution command
* @param arg the execution argument
* @param arg is the argument of the function to execute the command.
*
* @return the error code
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that this function failed to execute.
*/
rt_err_t
rt_mb_control
(
rt_mailbox_t
mb
,
int
cmd
,
void
*
arg
)
{
...
...
@@ -1922,26 +2399,64 @@ rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg)
return
-
RT_ERROR
;
}
RTM_EXPORT
(
rt_mb_control
);
/**@}*/
#endif
/* RT_USING_MAILBOX */
#ifdef RT_USING_MESSAGEQUEUE
/**
* @addtogroup messagequeue
*/
/**@{*/
struct
rt_mq_message
{
struct
rt_mq_message
*
next
;
};
/**
* This function will initialize a message queue and put it under control of
* resource management.
* @brief Initialize a static messagequeue object.
*
* @note For the static messagequeue object, its memory space is allocated by the compiler during compiling,
* and shall placed on the read-write data segment or on the uninitialized data segment.
* By contrast, the rt_mq_create() function will allocate memory space automatically
* and initialize the messagequeue.
*
* @see rt_mq_create()
*
* @param mq is a pointer to the messagequeue to initialize. It is assumed that storage for
* the messagequeue will be allocated in your application.
*
* @param name is a pointer to the name that given to the messagequeue.
*
* @param msgpool is a pointer to the starting address of the memory space you allocated for
* the messagequeue in advance.
* In other words, msgpool is a pointer to the messagequeue buffer of the starting address.
*
* @param msg_size is the maximum length of a message in the messagequeue (Unit: Byte).
*
* @param pool_size is the size of the memory space allocated for the messagequeue in advance.
*
* @param flag is the messagequeue flag, which determines the queuing way of how multiple threads wait
* when the messagequeue is not available.
* The messagequeue flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* @param mq the message object
* @param name the name of message queue
* @param msgpool the beginning address of buffer to save messages
* @param msg_size the maximum size of message
* @param pool_size the size of buffer to save messages
* @param flag the flag of message queue
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* @return the operation status, RT_EOK on successful
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this messagequeue will become non-real-time threads.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it represents the initialization failed.
*
* @warning This function can ONLY be called from threads.
*/
rt_err_t
rt_mq_init
(
rt_mq_t
mq
,
const
char
*
name
,
...
...
@@ -1996,12 +2511,24 @@ rt_err_t rt_mq_init(rt_mq_t mq,
}
RTM_EXPORT
(
rt_mq_init
);
/**
* This function will detach a message queue object from resource management
* @brief This function will detach a static messagequeue object.
*
* @note This function is used to detach a static messagequeue object which is initialized by rt_mq_init() function.
* By contrast, the rt_mq_delete() function will delete a messagequeue object.
* When the messagequeue is successfully detached, it will resume all suspended threads in the messagequeue list.
*
* @
param mq the message queue object
* @
see rt_mq_delete()
*
* @return the operation status, RT_EOK on successful
* @param mq is a pointer to a messagequeue object to be detached.
*
* @return Return the operation status. When the return value is RT_EOK, the initialization is successful.
* If the return value is any other values, it means that the messagequeue detach failed.
*
* @warning This function can ONLY detach a static messagequeue initialized by the rt_mq_init() function.
* If the messagequeue is created by the rt_mq_create() function, you MUST NOT USE this function to detach it,
* and ONLY USE the rt_mq_delete() function to complete the deletion.
*/
rt_err_t
rt_mq_detach
(
rt_mq_t
mq
)
{
...
...
@@ -2024,14 +2551,36 @@ RTM_EXPORT(rt_mq_detach);
#ifdef RT_USING_HEAP
/**
* This function will create a message queue object from system resource
* @brief Creating a messagequeue object.
*
* @note For the messagequeue object, its memory space is allocated automatically.
* By contrast, the rt_mq_init() function will initialize a static messagequeue object.
*
* @see rt_mq_init()
*
* @param name the name of message queue
* @param msg_size the size of message
* @param max_msgs the maximum number of message in queue
* @param flag the flag of message queue
* @param name is a pointer that given to the messagequeue.
*
* @return the created message queue, RT_NULL on error happen
* @param msg_size is the maximum length of a message in the messagequeue (Unit: Byte).
*
* @param max_msgs is the maximum number of messages in the messagequeue.
*
* @param flag is the messagequeue flag, which determines the queuing way of how multiple threads wait
* when the messagequeue is not available.
* The messagequeue flag can be ONE of the following values:
*
* RT_IPC_FLAG_PRIO The pending threads will queue in order of priority.
*
* RT_IPC_FLAG_FIFO The pending threads will queue in the first-in-first-out method
* (also known as first-come-first-served (FCFS) scheduling strategy).
*
* NOTE: RT_IPC_FLAG_FIFO is a non-real-time scheduling mode. It is strongly recommended to
* use RT_IPC_FLAG_PRIO to ensure the thread is real-time UNLESS your applications concern about
* the first-in-first-out principle, and you clearly understand that all threads involved in
* this messagequeue will become non-real-time threads.
*
* @return Return a pointer to the messagequeue object. When the return value is RT_NULL, it means the creation failed.
*
* @warning This function can NOT be called in interrupt context. You can use macor RT_DEBUG_NOT_IN_INTERRUPT to check it.
*/
rt_mq_t
rt_mq_create
(
const
char
*
name
,
rt_size_t
msg_size
,
...
...
@@ -2094,12 +2643,25 @@ rt_mq_t rt_mq_create(const char *name,
}
RTM_EXPORT
(
rt_mq_create
);
/**
*
This function will delete a message queue object and release the memory
*
@brief This function will delete a messagequeue object and release the memory.
*
* @param mq the message queue object
* @note This function is used to delete a messagequeue object which is created by the rt_mq_create() function.
* By contrast, the rt_mq_detach() function will detach a static messagequeue object.
* When the messagequeue is successfully deleted, it will resume all suspended threads in the messagequeue list.
*
* @return the error code
* @see rt_mq_detach()
*
* @param mq is a pointer to a messagequeue object to be deleted.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the messagequeue detach failed.
*
* @warning This function can ONLY delete a messagequeue initialized by the rt_mq_create() function.
* If the messagequeue is initialized by the rt_mq_init() function, you MUST NOT USE this function to delete it,
* ONLY USE the rt_mq_detach() function to complete the detachment.
* for example,the rt_mq_create() function, it cannot be called in interrupt context.
*/
rt_err_t
rt_mq_delete
(
rt_mq_t
mq
)
{
...
...
@@ -2126,16 +2688,35 @@ rt_err_t rt_mq_delete(rt_mq_t mq)
RTM_EXPORT
(
rt_mq_delete
);
#endif
/* RT_USING_HEAP */
/**
* This function will send a message to message queue object. If the message queue is full,
* current thread will be suspended until timeout.
* @brief This function will send a message to the messagequeue object. If
* there is a thread suspended on the messagequeue, the thread will be
* resumed.
*
* @note When using this function to send a message, if the messagequeue is
* fully used, the current thread will wait for a timeout. If reaching
* the timeout and there is still no space available, the sending
* thread will be resumed and an error code will be returned. By
* contrast, the rt_mq_send() function will return an error code
* immediately without waiting when the messagequeue if fully used.
*
* @see rt_mq_send()
*
* @param mq is a pointer to the messagequeue object to be sent.
*
* @param buffer is the content of the message.
*
* @param mq the message queue object
* @param buffer the message
* @param size the size of buffer
* @param timeout the waiting time
* @param size is the length of the message(Unit: Byte).
*
* @return the error code
* @param timeout is a timeout period (unit: an OS tick).
*
* @return Return the operation status. When the return value is RT_EOK, the
* operation is successful. If the return value is any other values,
* it means that the messagequeue detach failed.
*
* @warning This function can be called in interrupt context and thread
* context.
*/
rt_err_t
rt_mq_send_wait
(
rt_mq_t
mq
,
const
void
*
buffer
,
...
...
@@ -2298,15 +2879,28 @@ rt_err_t rt_mq_send_wait(rt_mq_t mq,
}
RTM_EXPORT
(
rt_mq_send_wait
)
/**
* This function will send a message to message queue object, if there are
* threads suspended on message queue object, it will be waked up.
* @brief This function will send a message to the messagequeue object.
* If there is a thread suspended on the messagequeue, the thread will be resumed.
*
* @note When using this function to send a message, if the messagequeue is fully used,
* the current thread will wait for a timeout.
* By contrast, when the messagequeue is fully used, the rt_mq_send_wait() function will
* return an error code immediately without waiting.
*
* @see rt_mq_send_wait()
*
* @param mq is a pointer to the messagequeue object to be sent.
*
* @param buffer is the content of the message.
*
* @param size is the length of the message(Unit: Byte).
*
* @param mq the message queue object
* @param buffer the message
* @param size the size of buffer
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the messagequeue detach failed.
*
* @
return the error code
* @
warning This function can be called in interrupt context and thread context.
*/
rt_err_t
rt_mq_send
(
rt_mq_t
mq
,
const
void
*
buffer
,
rt_size_t
size
)
{
...
...
@@ -2314,16 +2908,24 @@ rt_err_t rt_mq_send(rt_mq_t mq, const void *buffer, rt_size_t size)
}
RTM_EXPORT
(
rt_mq_send
);
/**
* This function will send an urgent message to message queue object, which
* means the message will be inserted to the head of message queue. If there
* are threads suspended on message queue object, it will be waked up.
* @brief This function will send an urgent message to the messagequeue object.
*
* @note This function is almost the same as the rt_mq_send() function. The only difference is that
* when sending an urgent message, the message is placed at the head of the messagequeue so that
* the recipient can receive the urgent message first.
*
* @see rt_mq_send()
*
* @param mq is a pointer to the messagequeue object to be sent.
*
* @param mq the message queue object
* @param buffer the message
* @param size the size of buffer
* @param buffer is the content of the message.
*
* @return the error code
* @param size is the length of the message(Unit: Byte).
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox detach failed.
*/
rt_err_t
rt_mq_urgent
(
rt_mq_t
mq
,
const
void
*
buffer
,
rt_size_t
size
)
{
...
...
@@ -2406,17 +3008,25 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
}
RTM_EXPORT
(
rt_mq_urgent
);
/**
* This function will receive a message from message queue object, if there is
* no message in message queue object, the thread shall wait for a specified
* time.
* @brief This function will receive a message from message queue object,
* if there is no message in messagequeue object, the thread shall wait for a specified time.
*
* @note Only when there is mail in the mailbox, the receiving thread can get the mail immediately and return RT_EOK,
* otherwise the receiving thread will be suspended until timeout.
* If the mail is not received within the specified time, it will return -RT_ETIMEOUT.
*
* @param mq is a pointer to the messagequeue object to be received.
*
* @param mq the message queue object
* @param buffer the received message will be saved in
* @param size the size of buffer
* @param timeout the waiting time
* @param buffer is the content of the message.
*
* @return the error code
* @param size is the length of the message(Unit: Byte).
*
* @param timeout is a timeout period (unit: an OS tick).
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that the mailbox release failed.
*/
rt_err_t
rt_mq_recv
(
rt_mq_t
mq
,
void
*
buffer
,
...
...
@@ -2568,15 +3178,20 @@ rt_err_t rt_mq_recv(rt_mq_t mq,
}
RTM_EXPORT
(
rt_mq_recv
);
/**
* This function can get or set some extra attributions of a message queue
* object.
* @brief This function will set some extra attributions of a messagequeue object.
*
* @note Currently this function only supports the RT_IPC_CMD_RESET command to reset the messagequeue.
*
* @param mq the message queue object
* @param cmd the execution command
* @param arg the execution argument
* @param mq is a pointer to a messagequeue object.
*
* @return the error code
* @param cmd is a command used to configure some attributions of the messagequeue.
*
* @param arg is the argument of the function to execute the command.
*
* @return Return the operation status. When the return value is RT_EOK, the operation is successful.
* If the return value is any other values, it means that this function failed to execute.
*/
rt_err_t
rt_mq_control
(
rt_mq_t
mq
,
int
cmd
,
void
*
arg
)
{
...
...
@@ -2628,6 +3243,8 @@ rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg)
return
-
RT_ERROR
;
}
RTM_EXPORT
(
rt_mq_control
);
/**@}*/
#endif
/* RT_USING_MESSAGEQUEUE */
/**@}*/
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录