代码拉取完成，页面将自动刷新
同步操作将从 jorya_txj/raw-os 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
/*
raw os - Copyright (C) Lingjun Chen(jorya_txj).
This file is part of raw os.
raw os is free software; you can redistribute it it under the terms of the
GNU General Public License as published by the Free Software Foundation;
either version 3 of the License, or (at your option) any later version.
raw os is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. if not, write email to jorya.txj@gmail.com
---
A special exception to the LGPL can be applied should you wish to distribute
a combined work that includes raw os, without being obliged to provide
the source code for any proprietary components. See the file exception.txt
for full details of how and when the exception can be applied.
*/
/* 2012-4 Created by jorya_txj
* xxxxxx please added here
*/
#include <raw_api.h>
#if (CONFIG_RAW_QUEUE > 0)
/*
************************************************************************************************************************
* Create a queue
*
* Description: This function is called to create a queue.
*
* Arguments :p_q is the address of queue object want to be initialized
* -----
* name_ptr is the queue object name
* -----
* msg_start is the address of pointer array.
* ------
* number is the number of elements of the queue.
* Returns
* RAW_SUCCESS: raw os return success
* Note(s)
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_create(RAW_QUEUE *p_q, RAW_U8 *p_name, void **msg_start, MSG_SIZE_TYPE number)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (msg_start == 0) {
return RAW_NULL_POINTER;
}
if (number == 0u) {
return RAW_ZERO_NUMBER;
}
#endif
/*init the queue blocked list*/
list_init(&p_q->common_block_obj.block_list);
p_q->common_block_obj.name = p_name;
p_q->common_block_obj.block_way = RAW_BLOCKED_WAY_PRIO;
p_q->msg_q.queue_start = msg_start; /* Initialize the queue */
p_q->msg_q.queue_end = &msg_start[number];
p_q->msg_q.write = msg_start;
p_q->msg_q.read = msg_start;
p_q->msg_q.size = number;
p_q->msg_q.current_numbers = 0u;
p_q->msg_q.peak_numbers = 0u;
p_q->queue_send_notify = 0;
p_q->queue_full_callback = 0;
list_insert(&(raw_task_debug.queue_head), &p_q->queue_debug_list);
p_q->common_block_obj.object_type = RAW_QUEUE_OBJ_TYPE;
TRACE_QUEUE_CREATE(raw_task_active, p_q);
return RAW_SUCCESS;
}
#if (CONFIG_RAW_QUEUE_BLOCK_WAY_SET > 0)
RAW_OS_ERROR raw_queue_block_way_set(RAW_QUEUE *p_q, RAW_BLOCKED_WAY block_way)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
#endif
p_q->common_block_obj.block_way = block_way;
return RAW_SUCCESS;
}
#endif
RAW_OS_ERROR raw_queue_full_register(RAW_QUEUE *p_q, QUEUE_FULL_CALLBACK callback_full)
{
RAW_SR_ALLOC();
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
RAW_CPU_DISABLE();
p_q->queue_full_callback = callback_full;
RAW_CPU_ENABLE();
return RAW_SUCCESS;
}
RAW_OS_ERROR msg_post(RAW_QUEUE *p_q, void *p_void, RAW_U8 opt_send_method, RAW_U8 opt_wake_all)
{
LIST *block_list_head;
RAW_SR_ALLOC();
/*This is only needed when system zero interrupt feature is enabled*/
#if (CONFIG_INTERRUPT_PRIORITY_CHECK > 0)
port_interrupt_priority_check();
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
block_list_head = &p_q->common_block_obj.block_list;
if (p_q->msg_q.current_numbers >= p_q->msg_q.size) {
RAW_CRITICAL_EXIT();
TRACE_QUEUE_MSG_MAX(raw_task_active, p_q, p_void, opt_send_method);
if (p_q->queue_full_callback) {
p_q->queue_full_callback(p_q, p_void);
}
return RAW_MSG_MAX;
}
/*Queue is not full here, if there is no blocked receive task*/
if (is_list_empty(block_list_head)) {
p_q->msg_q.current_numbers++;
/*update peak_numbers for debug*/
if (p_q->msg_q.current_numbers > p_q->msg_q.peak_numbers) {
p_q->msg_q.peak_numbers = p_q->msg_q.current_numbers;
}
if (opt_send_method == SEND_TO_END) {
*p_q->msg_q.write++ = p_void;
if (p_q->msg_q.write == p_q->msg_q.queue_end) {
p_q->msg_q.write = p_q->msg_q.queue_start;
}
}
else {
/* Wrap read pointer to end if we are at the 1st queue entry */
if (p_q->msg_q.read == p_q->msg_q.queue_start) {
p_q->msg_q.read = p_q->msg_q.queue_end;
}
p_q->msg_q.read--;
*p_q->msg_q.read = p_void; /* Insert message into queue */
}
RAW_CRITICAL_EXIT();
/*if queue is registered with notify function just call it*/
if (p_q->queue_send_notify) {
p_q->queue_send_notify(p_q);
}
TRACE_QUEUE_MSG_POST(raw_task_active, p_q, p_void, opt_send_method);
return RAW_SUCCESS;
}
/*wake all the task blocked on this queue*/
if (opt_wake_all) {
while (!is_list_empty(block_list_head)) {
wake_send_msg(raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list), p_void);
TRACE_QUEUE_WAKE_TASK(raw_task_active, raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list), p_void, opt_wake_all);
}
}
/*wake hignhest priority task blocked on this queue and send msg to it*/
else {
wake_send_msg(raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list), p_void);
TRACE_QUEUE_WAKE_TASK(raw_task_active, raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list), p_void, opt_wake_all);
}
RAW_CRITICAL_EXIT();
raw_sched();
return RAW_SUCCESS;
}
/*
************************************************************************************************************************
* Post a msg to the queue front
*
* Description: This function is called to post a msg to the queue front and implement LIFO.
*
* Arguments :p_q is the address of the queue object
* -----
* p_void is the address of the msg
* -----
*
*
* Returns
* RAW_SUCCESS: raw os return success
* RAW_MSG_MAX:queue is full
*
*
*
* Note(s)
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_front_post(RAW_QUEUE *p_q, void *p_void)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (p_void == 0) {
return RAW_NULL_POINTER;
}
#endif
TRACE_QUEUE_FP_TIME_RECORD(p_q, p_void);
return msg_post(p_q, p_void,SEND_TO_FRONT, WAKE_ONE_QUEUE);
}
/*
************************************************************************************************************************
* Post a msg to the queue end
*
* Description: This function is called to post a msg to the queue end and implement FIFO.
*
* Arguments :p_q is the address of the queue object
* -----
* p_void is the address of the msg
* -----
*
*
* Returns
* RAW_SUCCESS: raw os return success
* RAW_MSG_MAX:queue is full
*
*
*
* Note(s)
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_end_post(RAW_QUEUE *p_q, void *p_void)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (p_void == 0) {
return RAW_NULL_POINTER;
}
#endif
TRACE_QUEUE_EP_TIME_RECORD(p_q, p_void);
return msg_post(p_q, p_void, SEND_TO_END, WAKE_ONE_QUEUE);
}
/*
************************************************************************************************************************
* Notify function call back
*
* Description: This function is called to post a msg to the queue end and implement FIFO.
*
* Arguments :p_q is the address of the queue object
* -----
* p_void is the address of the msg
* -----
*
*
* Returns
* RAW_SUCCESS: raw os return success
* RAW_MSG_MAX:queue is full
*
*
*
* Note(s)
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_post_notify(RAW_QUEUE *p_q, void *p_void)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (p_void == 0) {
return RAW_NULL_POINTER;
}
#endif
return msg_post(p_q, p_void, SEND_TO_END, WAKE_ONE_QUEUE);
}
/*
************************************************************************************************************************
* Post a msg to the all the task waiting for on this queue
*
* Description: This function is called to post a msg to the queue end and implement FIFO or LIFO as opt specified.
*
* Arguments :p_q is the address of the queue object
* -----
* p_void is the address of the msg
* -----
* opt: the opt option is:
* SEND_TO_END implement FIFO
* SEND_TO_FRONTimplement LIFO
* -----
*
*
* Returns RAW_SUCCESS: raw os return success
* RAW_MSG_MAX:queue is full
*
* Note(s) THis function will wake all the task waiting for this queue other than one!
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_all_post(RAW_QUEUE *p_q, void *p_void, RAW_U8 opt)
{
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (p_void == 0) {
return RAW_NULL_POINTER;
}
#endif
TRACE_QUEUE_AP_TIME_RECORD(p_q, p_void, opt);
return msg_post(p_q, p_void, opt, WAKE_ALL_QUEUE);
}
/*
************************************************************************************************************************
* Register notify function to queue
*
* Description: This function is called to Register notify function to queue.
*
* Arguments :p_q is the address of the queue object
* -----
* notify_function is the function to be called whennever send queue data to it.
* -----
*
*
* Returns
* RAW_SUCCESS: raw os return success
*
* Note(s) This function is normally used to implement pending on multi object function.
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_send_notify(RAW_QUEUE *p_q, QUEUE_SEND_NOTIFY notify_function)
{
RAW_SR_ALLOC();
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
p_q->queue_send_notify = notify_function;
RAW_CRITICAL_EXIT();
return RAW_SUCCESS;
}
/*
************************************************************************************************************************
* Receive a msg
*
* Description: This function is called to receive a msg
*
* Arguments :p_q is the address of the queue object
* -----
* msg is the address of a point, and this pointer contains address of the msg.
* -----
* wait_option: is how the service behaves if the msg queue is full.
* The wait options are
* defined as follows:
* RAW_NO_WAIT (0x00000000)
* RAW_WAIT_FOREVER (0xFFFFFFFF)
* timeout value (0x00000001
* through
* 0xFFFFFFFE)
*
* Returns
* RAW_SUCCESS: raw os return success
* RAW_BLOCK_DEL: if this queue is deleted.
* RAW_BLOCK_TIMEOUT: queue is still full during waiting time when sending msg.
* RAW_BLOCK_ABORT:queue is aborted during waiting time when sending msg.
* Note(s) if no msg received then msg will get null pointer(0). ISR can call this function if only wait_option equal RAW_NO_WAIT.
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_receive(RAW_QUEUE *p_q, RAW_TICK_TYPE wait_option, void **msg)
{
void *pmsg;
RAW_OS_ERROR block_result;
RAW_SR_ALLOC();
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (raw_int_nesting && (wait_option != RAW_NO_WAIT)) {
return RAW_NOT_CALLED_BY_ISR;
}
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (msg == 0) {
return RAW_NULL_POINTER;
}
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
/*if queue has msgs, just receive it*/
if (p_q->msg_q.current_numbers) {
pmsg = *p_q->msg_q.read++;
if (p_q->msg_q.read == p_q->msg_q.queue_end) {
/*wrap around to start*/
p_q->msg_q.read = p_q->msg_q.queue_start;
}
*msg = pmsg;
p_q->msg_q.current_numbers--;
RAW_CRITICAL_EXIT();
TRACE_QUEUE_GET_MSG(raw_task_active, p_q, wait_option, *msg);
return RAW_SUCCESS;
}
if (wait_option == RAW_NO_WAIT) {
*msg = (void *)0;
RAW_CRITICAL_EXIT();
return RAW_NO_PEND_WAIT;
}
/*if system is locked, block operation is not allowed*/
SYSTEM_LOCK_PROCESS_QUEUE();
raw_pend_object((RAW_COMMON_BLOCK_OBJECT *)p_q, raw_task_active, wait_option);
RAW_CRITICAL_EXIT();
TRACE_QUEUE_GET_BLOCK(raw_task_active, p_q, wait_option);
raw_sched();
USER_CPU_INT_DISABLE();
block_result = block_state_post_process(raw_task_active);
switch (block_result) {
case RAW_SUCCESS:
*msg = raw_task_active->msg;
break;
default:
*msg = (void *)0;
break;
}
USER_CPU_INT_ENABLE();
return block_result;
}
/*
************************************************************************************************************************
* Check whether queue obj is full or not
*
* Description: This function is called to Check whether queue obj is full or not.
*
* Arguments :p_q is the address of the queue object
* -----
*
*
* Returns
* RAW_QUEUE_CHECK_FULL: queue obj is full
* RAW_QUEUE_CHECK_NOT_FULL: queue obj is not full
*
*Note(s)
*
*
************************************************************************************************************************
*/
RAW_OS_ERROR raw_queue_full_check(RAW_QUEUE *p_q)
{
RAW_SR_ALLOC();
RAW_OS_ERROR full_check_ret;
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
if (p_q->msg_q.current_numbers >= p_q->msg_q.size) {
full_check_ret = RAW_QUEUE_CHECK_FULL;
}
else {
full_check_ret = RAW_QUEUE_CHECK_NOT_FULL;
}
RAW_CRITICAL_EXIT();
return full_check_ret;
}
/*
************************************************************************************************************************
* Flush a queue
*
* Description: This service deletes all messages stored in the specified message queue.
* If the queue is empty, this service does nothing.
*
* Arguments :p_q is the address of the queue object
* -----
*
*
*Returns RAW_SUCCESS: raw os return success
*
*
* Note(s) Be careful This api will probably cause memory leak.
*
*
************************************************************************************************************************
*/
#if (CONFIG_RAW_QUEUE_FLUSH > 0)
RAW_OS_ERROR raw_queue_flush(RAW_QUEUE *p_q)
{
RAW_SR_ALLOC();
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
/*Reset read and write pointer to init position*/
p_q->msg_q.write = p_q->msg_q.queue_start;
p_q->msg_q.read = p_q->msg_q.queue_start;
p_q->msg_q.current_numbers = 0u;
RAW_CRITICAL_EXIT();
TRACE_QUEUE_FLUSH(raw_task_active, p_q);
return RAW_SUCCESS;
}
#endif
/*
************************************************************************************************************************
* Delete a queue
*
* Description: This function is called to delete a queue.
*
* Arguments :p_q is the address of this queue object
* -----
* All blocked task will be waken up and return RAW_BLOCK_DEL.
*
* Returns
* RAW_SUCCESS: raw os return success
* Note(s)
*
*
************************************************************************************************************************
*/
#if (CONFIG_RAW_QUEUE_DELETE > 0)
RAW_OS_ERROR raw_queue_delete(RAW_QUEUE *p_q)
{
LIST *block_list_head;
RAW_SR_ALLOC();
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (raw_int_nesting) {
return RAW_NOT_CALLED_BY_ISR;
}
#endif
RAW_CRITICAL_ENTER();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
RAW_CRITICAL_EXIT();
return RAW_ERROR_OBJECT_TYPE;
}
block_list_head = &p_q->common_block_obj.block_list;
p_q->common_block_obj.object_type = RAW_OBJ_TYPE_NONE;
/*All task blocked on this queue is waken up*/
while (!is_list_empty(block_list_head)) {
delete_pend_obj(raw_list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));
}
list_delete(&p_q->queue_debug_list);
RAW_CRITICAL_EXIT();
TRACE_QUEUE_DELETE(raw_task_active, p_q);
raw_sched();
return RAW_SUCCESS;
}
#endif
/*
************************************************************************************************************************
* Get queue information
*
* Description: This function is called to get information form queue.
*
* Arguments :p_q is the address of this queue object
* -----
* msg_information is the address of RAW_MSG_INFO, which will be filled queue information
* -----
*
*
* Returns
* RAW_SUCCESS: raw os return success
*
* Note(s) Commonly for debug purpose
*
*
************************************************************************************************************************
*/
#if (CONFIG_RAW_QUEUE_GET_INFORMATION > 0)
RAW_OS_ERROR raw_queue_get_information(RAW_QUEUE *p_q, RAW_MSG_INFO *msg_information)
{
LIST *block_list_head;
RAW_SR_ALLOC();
#if (RAW_QUEUE_FUNCTION_CHECK > 0)
if (p_q == 0) {
return RAW_NULL_OBJECT;
}
if (msg_information == 0) {
return RAW_NULL_POINTER;
}
#endif
USER_CPU_INT_DISABLE();
if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
USER_CPU_INT_ENABLE();
return RAW_ERROR_OBJECT_TYPE;
}
block_list_head = &p_q->common_block_obj.block_list;
msg_information->msg_q.peak_numbers = p_q->msg_q.peak_numbers;
msg_information->msg_q.current_numbers = p_q->msg_q.current_numbers;
msg_information->msg_q.queue_start = p_q->msg_q.queue_start;
msg_information->msg_q.queue_end = p_q->msg_q.queue_end;
msg_information->msg_q.read = p_q->msg_q.read;
msg_information->msg_q.write = p_q->msg_q.write;
msg_information->msg_q.size = p_q->msg_q.size;
msg_information->suspend_entry = block_list_head->next;
USER_CPU_INT_ENABLE();
return RAW_SUCCESS;
}
#endif
#endif
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手