void mutex_test() { if (test_started_raw) { return; } test_started_raw = 1; raw_task_create(&test_mutex_obj[1], (RAW_U8 *)"mutex_task1", 0, 10, 0, test_mutex_stack1, TEST_TASK_STK_SIZE , test_mutex1, 1); raw_task_create(&test_mutex_obj[2], (RAW_U8 *)"mutex_task2", 0, 30, 10, test_mutex_stack2, TEST_TASK_STK_SIZE , test_mutex2, 1); raw_task_create(&test_mutex_obj[3], (RAW_U8 *)"mutex_task3", 0, 40, 10, test_mutex_stack3, TEST_TASK_STK_SIZE , test_mutex3, 1); }
void mem_test() { if (test_started_raw) { return; } test_started_raw = 1; #if 0 raw_task_create(&test_mem_obj, (RAW_U8 *)"task2", 0, 10, 0, test_mem_stack, TEST_TASK_STK_SIZE , test_page, 1); #endif raw_task_create(&test_heap_obj, (RAW_U8 *)"task_heap", 0, 10, 0, test_heap_stack, TEST_TASK_STK_SIZE , test_heap, 1); }
/* ************************************************************************************************************************ * Create an active object * * Description: This function is called to post an event to active object * * Arguments :me is the address of this active object * --------- * prio is the priority of this active object * --------- * msg_start is the start address of active queue which is belonged to this active object * --------- * qLen is the active queue length * --------- * stkSto is the start stack address of this active object * --------- * stkSize is the stack size of this active object * --------- * event is the init event. * Returns * * Note(s) * * ************************************************************************************************************************ */ void active_object_create(ACTIVE_OBJECT_STRUCT *me, RAW_U8 prio, void **msg_start, RAW_U32 qLen, void *stkSto, RAW_U32 stkSize, STATE_EVENT *event) { RAW_OS_ERROR err; err = raw_queue_create(&me->active_queue, (RAW_U8 *)"queue", msg_start, qLen); if (err != RAW_SUCCESS) { RAW_ASSERT(0); } me->prio = prio; hsm_init(&me->father, event); me->user_data = 1; err = raw_task_create(&me->thread, (RAW_U8 *)"task5", me, me->prio, 0, stkSto, stkSize, active_task_function, 1); if (err != RAW_SUCCESS) { RAW_ASSERT(0); } }
void test_block() { if(1 == test_switch) { return; } test_switch = 1; if (RAW_SUCCESS != raw_block_pool_create(&mem_pool, "pool_block1", 32, buffer, 1024)) { __put_char("error ", 6); return; } raw_task_create(&test_task_obj, (RAW_U8 *)"task1", 0, 5, 10, test_task_stack1, TEST_TASK_STK_SIZE , test_task1, 1); }
void tick_task_start(void) { /*Create tick task to caculate task sleep and timeout*/ raw_task_create(&tick_task_obj, (RAW_U8 *)"tick_task_object", 0, TICK_TASK_PRIORITY, 0, tick_task_stack, TICK_TASK_STACK_SIZE, tick_task_process, 1); raw_task_semaphore_create(&tick_task_obj, &tick_semaphore_obj, (RAW_U8 *)"tick_semaphore_obj", 0); }
void queue_test2_mqueue() { if (test_started_raw) { return; } test_started_raw = 1; raw_task_create(&test_queue_obj1_mqueue[1], (RAW_U8 *)"task1", 0, 10, 0, test_queue_stack11_mqueue, TEST_TASK_STK_SIZE , driver_send_task_mqueue, 1); raw_task_create(&test_queue_obj1_mqueue[2], (RAW_U8 *)"task2", 0, 11, 10, test_queue_stack22_mqueue, TEST_TASK_STK_SIZE , net_receive_task_mqueue, 1); raw_task_create(&test_queue_obj1_mqueue[3], (RAW_U8 *)"task3", 0, 12, 10, test_queue_stack33_mqueue, TEST_TASK_STK_SIZE , app_receive_task1_mqueue, 1); raw_task_create(&test_queue_obj1_mqueue[4], (RAW_U8 *)"task4", 0, 13, 10, test_queue_stack44_mqueue, TEST_TASK_STK_SIZE , app_receive_task2_mqueue, 1); raw_task_create(&test_queue_obj1_mqueue[5], (RAW_U8 *)"task4", 0, 14, 10, test_queue_stack55_mqueue, TEST_TASK_STK_SIZE , watch_task_mqueue, 1); }
/* ************************************************************************************************************************ * Init task 0 * * Description: This function is called to init task 0 * * Arguments :NONE * * Returns * * Note(s) * * ************************************************************************************************************************ */ void raw_task_0_init(void) { /*Create task 0 to handle fast interrupt event*/ raw_task_create(&raw_task_0_obj, (RAW_U8 *)"task_0_object", 0, 0, 0, task_0_stack, TASK_0_STACK_SIZE, task_0_process, 1); task_0_event_handler.handle_event = task_0_tick_handler; #if (CONFIG_RAW_ZERO_INTERRUPT > 0) int_msg_init(); #endif }
void queue_test_mqueue() { if (test_started_raw) { return; } test_started_raw = 1; raw_task_create(&test_queue_obj_mqueue[1], (RAW_U8 *)"task1", 0, 3, 0, test_queue_stack1_mqueue, TEST_TASK_STK_SIZE , test_queue1_mqueue, 1); raw_task_create(&test_queue_obj_mqueue[2], (RAW_U8 *)"task2", 0, 40, 10, test_queue_stack2_mqueue, TEST_TASK_STK_SIZE , test_queue2_mqueue, 1); raw_task_create(&test_queue_obj_mqueue[3], (RAW_U8 *)"task3", 0, 40, 10, test_queue_stack3_mqueue, TEST_TASK_STK_SIZE , test_queue3_mqueue, 1); raw_task_create(&test_queue_obj_mqueue[4], (RAW_U8 *)"task4", 0, 40, 10, test_queue_stack4_mqueue, TEST_TASK_STK_SIZE , test_queue4_mqueue, 1); raw_task_create(&test_queue_obj_mqueue[5], (RAW_U8 *)"task5", 0, 40, 10, test_queue_stack5_mqueue, TEST_TASK_STK_SIZE , test_queue5_mqueue, 1); }
void raw_timer_init(void) { raw_timer_ctrl = RAW_TIMER_RATE; timer_list_init(); /*Create a timer task to handle soft timer*/ raw_task_create(&raw_timer_obj, (RAW_U8 *)"timer_object", 0, TIMER_TASK_PRIORITY, 0, timer_task_stack, TIMER_STACK_SIZE, timer_task, 1); /*create a semaphore for timer task*/ raw_semaphore_create(&timer_sem, (RAW_U8 *)"timer_sem", 0); }
void task_0_test() { if (test_started_raw) { return; } //test_started_raw = 1; raw_task_create(&test_task_obj11, (RAW_U8 *)"task1", 0, 2, 0, test_task_stack11, TEST_TASK_STK_SIZE , test_task11, 1); }
void idle_event_test() { if (test_started_raw) { return; } test_started_raw = 1; raw_task_create(&test_obj2, (RAW_U8 *)"task1", 0, 9, 0, test_stack2, TEST_TASK_STK_SIZE , test_event_task2, 1); }
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg) { pthread_struct *thread_struct; void *stack_base; attr = attr; thread_struct = raw_malloc(sizeof(pthread_struct)); stack_base = raw_malloc(4 * DEFAULT_STACK_ELEMENT); *thread = thread_struct; raw_task_create(&thread_struct->task_obj, (RAW_U8 *)"task1", arg, 30, 0, stack_base, DEFAULT_STACK_ELEMENT, (RAW_TASK_ENTRY)start_routine, RAW_TASK_AUTO_START); raw_semaphore_create(&thread_struct->task_sem, "sem", 0); thread_struct->task_sem.common_block_obj.block_way = RAW_BLOCKED_WAY_FIFO; return 0; }
/* ************************************************************************************************************************ * Establish a work queue * * Description: This function is called to establish a work queue. * * Arguments :wq is the address of the work queue object. * --------- * work_task_priority is the work queue task priority * --------- * work_queue_stack_size is the work queue task stack size * --------- * work_queue_stack_base is the base work queue task address * --------- * msg_start is the start address of the msg, work queue need msg space. * ---------- * work_msg_size is the size of the msg * * Returns RAW_SUCCESS: raw os return success. * OTHERS:Fail. * * Note(s) :Do not use this API in interrupt. * * ************************************************************************************************************************ */ RAW_OS_ERROR work_queue_create(WORK_QUEUE_STRUCT *wq, RAW_U8 work_task_priority, RAW_U32 work_queue_stack_size, PORT_STACK *work_queue_stack_base, void **msg_start, RAW_U32 work_msg_size) { RAW_OS_ERROR ret; ret = raw_queue_create(&wq->queue, "work_queue", msg_start, work_msg_size); if (ret != RAW_SUCCESS) { return ret; } ret = raw_task_create(&wq->work_queue_task_obj, (RAW_U8 *)"work_queue", wq, work_task_priority, 0, work_queue_stack_base, work_queue_stack_size, work_queue_task, 1); return ret; }
/* ************************************************************************************************************************ * Init raw os * * Description: This function is called to init raw os. * * Arguments :None * ----- * * * * Returns RAW_U16: RAW_SUCCESS. * * Note(s) * * ************************************************************************************************************************ */ RAW_U16 raw_os_init(void) { TRACE_INIT(); raw_os_active = RAW_OS_STOPPED; run_queue_init(&raw_ready_queue); /*Init the tick heart system*/ tick_list_init(); #if (RAW_SYSTEM_CHECK > 0) /*Init the task head list*/ list_init(&(system_debug.task_head)); #endif #if (CONFIG_RAW_USER_HOOK > 0) raw_os_init_hook(); #endif /*Start the first idle task*/ raw_task_create(&raw_idle_obj, (RAW_U8 *)"idle_task", 0, IDLE_PRIORITY, 0, idle_stack, IDLE_STACK_SIZE, raw_idle_task, 1); #if (CONFIG_RAW_TIMER > 0) raw_timer_init(); #endif #if (CONFIG_RAW_TASK_0 > 0) raw_task_0_init(); #endif #if (CONFIG_RAW_TICK_TASK > 0) tick_task_start(); #endif #if (RAW_CONFIG_CPU_TASK > 0) cpu_task_start(); #endif return RAW_SUCCESS; }
void thread_test() { if (test_started_raw) { return; } test_started_raw = 1; aaa = 0x99887766; raw_task_create(&test_thread_obj, (RAW_U8 *)"task1", &aaa, 3, 0, test_thread_stack, TEST_TASK_STK_SIZE, test_thread, RAW_TASK_AUTO_START); }
/* ************************************************************************************************************************ * Init raw os * * Description: This function is called to init raw os. * * Arguments :None * ----- * * * * Returns RAW_U16: RAW_SUCCESS. * * Note(s) * * ************************************************************************************************************************ */ RAW_OS_ERROR raw_os_init(void) { TRACE_INIT(); raw_os_active = RAW_OS_STOPPED; run_queue_init(&raw_ready_queue); /*Init the tick heart system*/ tick_list_init(); /*Init the task debug head list*/ list_init(&(raw_task_debug.task_head)); #if (CONFIG_RAW_USER_HOOK > 0) raw_os_init_hook(); #endif /*Start the first idle task*/ raw_task_create(&raw_idle_obj, (RAW_U8 *)"idle_task", 0, IDLE_PRIORITY, 0, idle_stack, IDLE_STACK_SIZE, raw_idle_task, 1); /*The timer module need mutex*/ #if (CONFIG_RAW_TIMER > 0) raw_timer_init(); raw_mutex_create(&timer_mutex, (RAW_U8 *)"timer_mutex", RAW_MUTEX_INHERIT_POLICY, 0); #endif /*tick task to reduce interrupt time*/ #if (CONFIG_RAW_TICK_TASK > 0) tick_task_start(); #endif /*For statistic*/ #if (RAW_CONFIG_CPU_TASK > 0) cpu_task_start(); #endif return RAW_SUCCESS; }