[update] remove RT_USING_TC
This commit is contained in:
liukangcc
Bernard Xiong
parent
7af733fa3f
commit
0c4e733737
|
|
@ -87,7 +87,6 @@
|
||||||
#define FINSH_USING_SYMTAB
|
#define FINSH_USING_SYMTAB
|
||||||
#define FINSH_USING_DESCRIPTION
|
#define FINSH_USING_DESCRIPTION
|
||||||
#define FINSH_THREAD_STACK_SIZE 8192
|
#define FINSH_THREAD_STACK_SIZE 8192
|
||||||
#define RT_USING_TC
|
|
||||||
|
|
||||||
|
|
||||||
/* SECTION: a runtime libc library */
|
/* SECTION: a runtime libc library */
|
||||||
|
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
from building import *
|
|
||||||
|
|
||||||
src = Split("""
|
|
||||||
tc_comm.c
|
|
||||||
thread_static.c
|
|
||||||
thread_dynamic.c
|
|
||||||
thread_priority.c
|
|
||||||
thread_same_priority.c
|
|
||||||
thread_static_simple.c
|
|
||||||
thread_dynamic_simple.c
|
|
||||||
thread_delete.c
|
|
||||||
thread_detach.c
|
|
||||||
thread_yield.c
|
|
||||||
thread_suspend.c
|
|
||||||
thread_resume.c
|
|
||||||
semaphore_static.c
|
|
||||||
semaphore_dynamic.c
|
|
||||||
semaphore_priority.c
|
|
||||||
semaphore_buffer_worker.c
|
|
||||||
semaphore_producer_consumer.c
|
|
||||||
mutex_simple.c
|
|
||||||
mutex_priority.c
|
|
||||||
event_simple.c
|
|
||||||
mbox_simple.c
|
|
||||||
mbox_send_wait.c
|
|
||||||
messageq_simple.c
|
|
||||||
timer_static.c
|
|
||||||
timer_dynamic.c
|
|
||||||
timer_stop_self.c
|
|
||||||
timer_control.c
|
|
||||||
timer_timeout.c
|
|
||||||
heap_malloc.c
|
|
||||||
heap_realloc.c
|
|
||||||
memp_simple.c
|
|
||||||
tc_sample.c
|
|
||||||
""")
|
|
||||||
|
|
||||||
group = DefineGroup('Examples', src,
|
|
||||||
depend = ['RT_USING_TC'],
|
|
||||||
CPPPATH=[GetCurrentDir()])
|
|
||||||
|
|
||||||
Return('group')
|
|
||||||
|
|
@ -1,78 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include <rthw.h>
|
|
||||||
|
|
||||||
#define CPU_USAGE_CALC_TICK 10
|
|
||||||
#define CPU_USAGE_LOOP 100
|
|
||||||
|
|
||||||
static rt_uint8_t cpu_usage_major = 0, cpu_usage_minor= 0;
|
|
||||||
static rt_uint32_t total_count = 0;
|
|
||||||
|
|
||||||
static void cpu_usage_idle_hook()
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_uint32_t count;
|
|
||||||
volatile rt_uint32_t loop;
|
|
||||||
|
|
||||||
if (total_count == 0)
|
|
||||||
{
|
|
||||||
/* get total count */
|
|
||||||
rt_enter_critical();
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while(rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
|
|
||||||
{
|
|
||||||
total_count ++;
|
|
||||||
loop = 0;
|
|
||||||
while (loop < CPU_USAGE_LOOP) loop ++;
|
|
||||||
}
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
|
|
||||||
count = 0;
|
|
||||||
/* get CPU usage */
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < CPU_USAGE_CALC_TICK)
|
|
||||||
{
|
|
||||||
count ++;
|
|
||||||
loop = 0;
|
|
||||||
while (loop < CPU_USAGE_LOOP) loop ++;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* calculate major and minor */
|
|
||||||
if (count < total_count)
|
|
||||||
{
|
|
||||||
count = total_count - count;
|
|
||||||
cpu_usage_major = (count * 100) / total_count;
|
|
||||||
cpu_usage_minor = ((count * 100) % total_count) * 100 / total_count;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
total_count = count;
|
|
||||||
|
|
||||||
/* no CPU usage */
|
|
||||||
cpu_usage_major = 0;
|
|
||||||
cpu_usage_minor = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void cpu_usage_get(rt_uint8_t *major, rt_uint8_t *minor)
|
|
||||||
{
|
|
||||||
RT_ASSERT(major != RT_NULL);
|
|
||||||
RT_ASSERT(minor != RT_NULL);
|
|
||||||
|
|
||||||
*major = cpu_usage_major;
|
|
||||||
*minor = cpu_usage_minor;
|
|
||||||
}
|
|
||||||
|
|
||||||
void cpu_usage_init()
|
|
||||||
{
|
|
||||||
/* set idle thread hook */
|
|
||||||
rt_thread_idle_sethook(cpu_usage_idle_hook);
|
|
||||||
}
|
|
||||||
|
|
@ -1,161 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* 程序清单：事件例程
|
|
||||||
*
|
|
||||||
* 这个程序会创建3个动态线程及初始化一个静态事件对象
|
|
||||||
* 一个线程等于事件对象上以接收事件；
|
|
||||||
* 一个线程定时发送事件 (事件3)
|
|
||||||
* 一个线程定时发送事件 (事件5)
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include <sys/time.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
static rt_thread_t tid3 = RT_NULL;
|
|
||||||
|
|
||||||
/* 事件控制块 */
|
|
||||||
static struct rt_event event;
|
|
||||||
|
|
||||||
/* 线程1入口函数 */
|
|
||||||
static void thread1_entry(void *param)
|
|
||||||
{
|
|
||||||
rt_uint32_t e;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* receive first event */
|
|
||||||
if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
|
|
||||||
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
|
|
||||||
RT_WAITING_FOREVER, &e) == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: AND recv event 0x%x\n", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_kprintf("thread1: delay 1s to prepare second event\n");
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* receive second event */
|
|
||||||
if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
|
|
||||||
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
|
|
||||||
RT_WAITING_FOREVER, &e) == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: OR recv event 0x%x\n", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_thread_delay(5);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口函数 */
|
|
||||||
static void thread2_entry(void *param)
|
|
||||||
{
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread2: send event1\n");
|
|
||||||
rt_event_send(&event, (1 << 3));
|
|
||||||
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程3入口函数 */
|
|
||||||
static void thread3_entry(void *param)
|
|
||||||
{
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread3: send event2\n");
|
|
||||||
rt_event_send(&event, (1 << 5));
|
|
||||||
|
|
||||||
rt_thread_delay(20);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int event_simple_init()
|
|
||||||
{
|
|
||||||
/* 初始化事件对象 */
|
|
||||||
rt_event_init(&event, "event", RT_IPC_FLAG_PRIO);
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程3 */
|
|
||||||
tid3 = rt_thread_create("t3",
|
|
||||||
thread3_entry, RT_NULL, /* 线程入口是thread3_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid3 != RT_NULL)
|
|
||||||
rt_thread_startup(tid3);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
if (tid3 != RT_NULL && tid3->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid3);
|
|
||||||
|
|
||||||
/* 执行事件对象脱离 */
|
|
||||||
rt_event_detach(&event);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_event_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
event_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_event_simple, a simple event example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
event_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,83 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is an example for heap malloc
|
|
||||||
*/
|
|
||||||
|
|
||||||
static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)
|
|
||||||
{
|
|
||||||
while (len)
|
|
||||||
{
|
|
||||||
if (*ptr != value)
|
|
||||||
return RT_FALSE;
|
|
||||||
ptr ++;
|
|
||||||
len --;
|
|
||||||
}
|
|
||||||
|
|
||||||
return RT_TRUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void heap_malloc_init()
|
|
||||||
{
|
|
||||||
rt_uint8_t res = TC_STAT_PASSED;
|
|
||||||
rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
|
|
||||||
|
|
||||||
ptr1 = rt_malloc(1);
|
|
||||||
ptr2 = rt_malloc(13);
|
|
||||||
ptr3 = rt_malloc(31);
|
|
||||||
ptr4 = rt_malloc(127);
|
|
||||||
ptr5 = rt_malloc(0);
|
|
||||||
|
|
||||||
memset(ptr1, 1, 1);
|
|
||||||
memset(ptr2, 2, 13);
|
|
||||||
memset(ptr3, 3, 31);
|
|
||||||
memset(ptr4, 4, 127);
|
|
||||||
|
|
||||||
if (mem_check(ptr1, 1, 1) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr2, 2, 13) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr3, 3, 31) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr4, 4, 127) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
|
|
||||||
rt_free(ptr4);
|
|
||||||
rt_free(ptr3);
|
|
||||||
rt_free(ptr2);
|
|
||||||
rt_free(ptr1);
|
|
||||||
|
|
||||||
if (ptr5 != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_free(ptr5);
|
|
||||||
}
|
|
||||||
|
|
||||||
tc_done(res);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
int _tc_heap_malloc()
|
|
||||||
{
|
|
||||||
heap_malloc_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_heap_malloc, a heap malloc test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
heap_malloc_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,111 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is an example for heap malloc
|
|
||||||
*/
|
|
||||||
|
|
||||||
static rt_bool_t mem_check(rt_uint8_t *ptr, rt_uint8_t value, rt_uint32_t len)
|
|
||||||
{
|
|
||||||
while (len)
|
|
||||||
{
|
|
||||||
if (*ptr != value) return RT_FALSE;
|
|
||||||
|
|
||||||
ptr ++;
|
|
||||||
len --;
|
|
||||||
}
|
|
||||||
|
|
||||||
return RT_TRUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void heap_realloc_init()
|
|
||||||
{
|
|
||||||
rt_uint8_t res = TC_STAT_PASSED;
|
|
||||||
rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
|
|
||||||
|
|
||||||
ptr1 = rt_malloc(1);
|
|
||||||
ptr2 = rt_malloc(13);
|
|
||||||
ptr3 = rt_malloc(31);
|
|
||||||
ptr4 = rt_malloc(127);
|
|
||||||
ptr5 = rt_malloc(0);
|
|
||||||
|
|
||||||
memset(ptr1, 1, 1);
|
|
||||||
memset(ptr2, 2, 13);
|
|
||||||
memset(ptr3, 3, 31);
|
|
||||||
memset(ptr4, 4, 127);
|
|
||||||
|
|
||||||
if (mem_check(ptr1, 1, 1) == RT_FALSE)
|
|
||||||
{
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
goto _free;
|
|
||||||
}
|
|
||||||
if (mem_check(ptr2, 2, 13) == RT_FALSE)
|
|
||||||
{
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
goto _free;
|
|
||||||
}
|
|
||||||
if (mem_check(ptr3, 3, 31) == RT_FALSE)
|
|
||||||
{
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
goto _free;
|
|
||||||
}
|
|
||||||
if (mem_check(ptr4, 4, 127) == RT_FALSE)
|
|
||||||
{
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
goto _free;
|
|
||||||
}
|
|
||||||
|
|
||||||
ptr1 = rt_realloc(ptr1, 13);
|
|
||||||
ptr2 = rt_realloc(ptr2, 31);
|
|
||||||
ptr3 = rt_realloc(ptr3, 127);
|
|
||||||
ptr4 = rt_realloc(ptr4, 1);
|
|
||||||
ptr5 = rt_realloc(ptr5, 0);
|
|
||||||
if (ptr5)
|
|
||||||
{
|
|
||||||
rt_kprintf("realloc(ptr, 0) should return NULL\n");
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (mem_check(ptr1, 1, 1) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr2, 2, 13) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr3, 3, 31) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
if (mem_check(ptr4, 4, 1) == RT_FALSE)
|
|
||||||
res = TC_STAT_FAILED;
|
|
||||||
|
|
||||||
_free:
|
|
||||||
rt_free(ptr4);
|
|
||||||
rt_free(ptr3);
|
|
||||||
rt_free(ptr2);
|
|
||||||
rt_free(ptr1);
|
|
||||||
|
|
||||||
tc_done(res);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
int _tc_heap_realloc()
|
|
||||||
{
|
|
||||||
heap_realloc_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_heap_realloc, a heap re-malloc test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
heap_realloc_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,150 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：邮箱例程_发送阻塞
|
|
||||||
*
|
|
||||||
* 这个程序用来测试邮箱发送时候的阻塞情况。
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
|
|
||||||
/* 邮箱控制块 */
|
|
||||||
static struct rt_mailbox mb;
|
|
||||||
/* 用于放邮件的内存池 */
|
|
||||||
static char mb_pool[32];
|
|
||||||
|
|
||||||
static char mb_str1[] = "I'm a mail!";
|
|
||||||
static char mb_str2[] = "this is another mail!";
|
|
||||||
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
unsigned char* str;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 从邮箱中收取邮件 */
|
|
||||||
if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
|
|
||||||
|
|
||||||
/* 延时20个OS Tick */
|
|
||||||
rt_thread_delay(50);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint8_t count;
|
|
||||||
char *str;
|
|
||||||
|
|
||||||
count = 0;
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
count ++;
|
|
||||||
if (count & 0x1)
|
|
||||||
{
|
|
||||||
/* 发送mb_str1地址到邮箱中 */
|
|
||||||
str = mb_str1;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* 发送mb_str2地址到邮箱中 */
|
|
||||||
str = mb_str2;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 不停的发送邮件，如果满了则等待10个tick，然后超时 */
|
|
||||||
if( rt_mb_send_wait(&mb, (rt_uint32_t)str,10) == RT_EOK )
|
|
||||||
rt_kprintf("thread2: sent a mail to mailbox, the content:%s\n", str);
|
|
||||||
else
|
|
||||||
rt_kprintf("thread2: timeout while waiting to send a mail.\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int mbox_send_wait_init()
|
|
||||||
{
|
|
||||||
/* 初始化一个mailbox */
|
|
||||||
rt_mb_init(&mb,
|
|
||||||
"mbt", /* 名称是mbt */
|
|
||||||
&mb_pool[0], /* 邮箱用到的内存池是mb_pool */
|
|
||||||
sizeof(mb_pool)/4, /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
|
|
||||||
RT_IPC_FLAG_PRIO); /* 采用PRIO方式进行线程等待 */
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 执行邮箱对象脱离 */
|
|
||||||
rt_mb_detach(&mb);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_mbox_send_wait()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
mbox_send_wait_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 300;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_mbox_send_wait, a example of mailbox send wait);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
mbox_send_wait_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,147 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：邮箱例程
|
|
||||||
*
|
|
||||||
* 这个程序会创建2个动态线程，一个静态的邮箱对象，其中一个线程往邮箱中发送邮件，
|
|
||||||
* 一个线程往邮箱中收取邮件。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
|
|
||||||
/* 邮箱控制块 */
|
|
||||||
static struct rt_mailbox mb;
|
|
||||||
/* 用于放邮件的内存池 */
|
|
||||||
static char mb_pool[128];
|
|
||||||
|
|
||||||
static char mb_str1[] = "I'm a mail!";
|
|
||||||
static char mb_str2[] = "this is another mail!";
|
|
||||||
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
unsigned char* str;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: try to recv a mail\n");
|
|
||||||
|
|
||||||
/* 从邮箱中收取邮件 */
|
|
||||||
if (rt_mb_recv(&mb, (rt_uint32_t*)&str, RT_WAITING_FOREVER) == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: get a mail from mailbox, the content:%s\n", str);
|
|
||||||
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint8_t count;
|
|
||||||
|
|
||||||
count = 0;
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
count ++;
|
|
||||||
if (count & 0x1)
|
|
||||||
{
|
|
||||||
/* 发送mb_str1地址到邮箱中 */
|
|
||||||
rt_mb_send(&mb, (rt_uint32_t)&mb_str1[0]);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* 发送mb_str2地址到邮箱中 */
|
|
||||||
rt_mb_send(&mb, (rt_uint32_t)&mb_str2[0]);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 延时20个OS Tick */
|
|
||||||
rt_thread_delay(20);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int mbox_simple_init()
|
|
||||||
{
|
|
||||||
/* 初始化一个mailbox */
|
|
||||||
rt_mb_init(&mb,
|
|
||||||
"mbt", /* 名称是mbt */
|
|
||||||
&mb_pool[0], /* 邮箱用到的内存池是mb_pool */
|
|
||||||
sizeof(mb_pool)/4, /* 大小是mb_pool大小除以4，因为一封邮件的大小是4字节 */
|
|
||||||
RT_IPC_FLAG_PRIO); /* 采用PRIO方式进行线程等待 */
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 执行邮箱对象脱离 */
|
|
||||||
rt_mb_detach(&mb);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_mbox_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
mbox_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_mbox_simple, a simple mailbox example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
mbox_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,150 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：内存池例程
|
|
||||||
*
|
|
||||||
* 这个程序会创建一个静态的内存池对象，2个动态线程。两个线程会试图分别从内存池中获得
|
|
||||||
* 内存块
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static rt_uint8_t *ptr[48];
|
|
||||||
static rt_uint8_t mempool[4096];
|
|
||||||
static struct rt_mempool mp;
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
char *block;
|
|
||||||
|
|
||||||
while(1)
|
|
||||||
{
|
|
||||||
for (i = 0; i < 48; i++)
|
|
||||||
{
|
|
||||||
/* 申请内存块 */
|
|
||||||
rt_kprintf("allocate No.%d\n", i);
|
|
||||||
if (ptr[i] == RT_NULL)
|
|
||||||
{
|
|
||||||
ptr[i] = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 继续申请一个内存块，因为已经没有内存块，线程应该被挂起 */
|
|
||||||
block = rt_mp_alloc(&mp, RT_WAITING_FOREVER);
|
|
||||||
rt_kprintf("allocate the block mem\n");
|
|
||||||
/* 释放这个内存块 */
|
|
||||||
rt_mp_free(block);
|
|
||||||
block = RT_NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口，线程2的优先级比线程1低，应该线程1先获得执行。*/
|
|
||||||
static void thread2_entry(void *parameter)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
while(1)
|
|
||||||
{
|
|
||||||
rt_kprintf("try to release block\n");
|
|
||||||
|
|
||||||
for (i = 0 ; i < 48; i ++)
|
|
||||||
{
|
|
||||||
/* 释放所有分配成功的内存块 */
|
|
||||||
if (ptr[i] != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_kprintf("release block %d\n", i);
|
|
||||||
|
|
||||||
rt_mp_free(ptr[i]);
|
|
||||||
ptr[i] = RT_NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 休眠10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int mempool_simple_init()
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < 48; i ++) ptr[i] = RT_NULL;
|
|
||||||
|
|
||||||
/* 初始化内存池对象 */
|
|
||||||
rt_mp_init(&mp, "mp1", &mempool[0], sizeof(mempool), 80);
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 执行内存池脱离 */
|
|
||||||
rt_mp_detach(&mp);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_mempool_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
mempool_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_mempool_simple, a memory pool example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
mempool_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,176 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：消息队列例程
|
|
||||||
*
|
|
||||||
* 这个程序会创建3个动态线程，一个线程会从消息队列中收取消息；一个线程会定时给消
|
|
||||||
* 息队列发送消息；一个线程会定时给消息队列发送紧急消息。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
static rt_thread_t tid3 = RT_NULL;
|
|
||||||
|
|
||||||
/* 消息队列控制块 */
|
|
||||||
static struct rt_messagequeue mq;
|
|
||||||
/* 消息队列中用到的放置消息的内存池 */
|
|
||||||
static char msg_pool[2048];
|
|
||||||
|
|
||||||
/* 线程1入口函数 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
char buf[128];
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_memset(&buf[0], 0, sizeof(buf));
|
|
||||||
|
|
||||||
/* 从消息队列中接收消息 */
|
|
||||||
if (rt_mq_recv(&mq, &buf[0], sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread1: recv msg from message queue, the content:%s\n", buf);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 延迟10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口函数 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
int i, result;
|
|
||||||
char buf[] = "this is message No.x";
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
for (i = 0; i < 10; i++)
|
|
||||||
{
|
|
||||||
buf[sizeof(buf) - 2] = '0' + i;
|
|
||||||
|
|
||||||
rt_kprintf("thread2: send message - %s\n", buf);
|
|
||||||
/* 发送消息到消息队列中 */
|
|
||||||
result = rt_mq_send(&mq, &buf[0], sizeof(buf));
|
|
||||||
if ( result == -RT_EFULL)
|
|
||||||
{
|
|
||||||
/* 消息队列满， 延迟1s时间 */
|
|
||||||
rt_kprintf("message queue full, delay 1s\n");
|
|
||||||
rt_thread_delay(100);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程3入口函数 */
|
|
||||||
static void thread3_entry(void* parameter)
|
|
||||||
{
|
|
||||||
char buf[] = "this is an urgent message!";
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread3: send an urgent message\n");
|
|
||||||
|
|
||||||
/* 发送紧急消息到消息队列中 */
|
|
||||||
rt_mq_urgent(&mq, &buf[0], sizeof(buf));
|
|
||||||
|
|
||||||
/* 延时25个OS Tick */
|
|
||||||
rt_thread_delay(25);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int messageq_simple_init()
|
|
||||||
{
|
|
||||||
/* 初始化消息队列 */
|
|
||||||
rt_mq_init(&mq, "mqt",
|
|
||||||
&msg_pool[0], /* 内存池指向msg_pool */
|
|
||||||
128 - sizeof(void*), /* 每个消息的大小是 128 - void* */
|
|
||||||
sizeof(msg_pool), /* 内存池的大小是msg_pool的大小 */
|
|
||||||
RT_IPC_FLAG_PRIO); /* 如果有多个线程等待，按照优先级由高到低的方法分配消息 */
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程3 */
|
|
||||||
tid3 = rt_thread_create("t3",
|
|
||||||
thread3_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid3 != RT_NULL)
|
|
||||||
rt_thread_startup(tid3);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
if (tid3 != RT_NULL && tid3->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid3);
|
|
||||||
|
|
||||||
/* 执行消息队列对象脱离 */
|
|
||||||
rt_mq_detach(&mq);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_messageq_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
messageq_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_messageq_simple, a simple message queue example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
messageq_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,434 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 创建7个进程，tid20、tid21、tid22、tid23、tid24、tid25、tid26、tid27、tid28、tid29
|
|
||||||
* 各任务优先级分别为20、21、22、23、24、25、26、27、28、29，
|
|
||||||
* 其中tid26最先获得锁，tid22不需要使用到互斥锁，其他所有进程均需要使用互斥锁，
|
|
||||||
* 通过各个进程的打印信息，观察各个进程获取到互斥锁后，优先级变化情况
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static rt_thread_t tid20 = RT_NULL;
|
|
||||||
static rt_thread_t tid21 = RT_NULL;
|
|
||||||
static rt_thread_t tid22 = RT_NULL;
|
|
||||||
static rt_thread_t tid23 = RT_NULL;
|
|
||||||
static rt_thread_t tid24 = RT_NULL;
|
|
||||||
static rt_thread_t tid25 = RT_NULL;
|
|
||||||
static rt_thread_t tid26 = RT_NULL;
|
|
||||||
static rt_thread_t tid27 = RT_NULL;
|
|
||||||
static rt_thread_t tid28 = RT_NULL;
|
|
||||||
static rt_thread_t tid29 = RT_NULL;
|
|
||||||
|
|
||||||
static rt_mutex_t mutex = RT_NULL;
|
|
||||||
|
|
||||||
static void thread20_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread20 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(30);
|
|
||||||
rt_kprintf("[%d] thread20 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread20 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread20, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid20->init_priority, tid20->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread20 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread21_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_kprintf("[%d] thread21 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(25);
|
|
||||||
rt_kprintf("[%d] thread21 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread21 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread21, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid21->init_priority, tid21->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread21 exit!\n", rt_tick_get());
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread22_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread22 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(20);
|
|
||||||
rt_kprintf("[%d] thread22 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 100)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread22 running..., init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid22->init_priority, tid22->current_priority);
|
|
||||||
rt_thread_delay(2);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread22 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread23_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_kprintf("[%d] thread23 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(15);
|
|
||||||
rt_kprintf("[%d] thread23 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread23 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread23, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid23->init_priority, tid23->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread23 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread24_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread24 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(10);
|
|
||||||
rt_kprintf("[%d] thread24 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread24 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread24, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid24->init_priority, tid24->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread24 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread25_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_kprintf("[%d] thread25 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(5);
|
|
||||||
rt_kprintf("[%d] thread25 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread25 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread25, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid25->init_priority, tid25->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread25 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread26_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread26 run!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread26 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 50)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread26, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid26->init_priority, tid26->current_priority);
|
|
||||||
rt_thread_delay(1);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread26 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread27_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread27 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(35);
|
|
||||||
rt_kprintf("[%d] thread27 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread27 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread27, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid27->init_priority, tid27->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread27 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread28_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread28 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(40);
|
|
||||||
rt_kprintf("[%d] thread28 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread28 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread28, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid28->init_priority, tid28->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread28 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread29_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
rt_kprintf("[%d] thread29 run!\n", rt_tick_get());
|
|
||||||
rt_thread_delay(45);
|
|
||||||
rt_kprintf("[%d] thread29 wake!\n", rt_tick_get());
|
|
||||||
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
rt_kprintf("[%d] thread29 take!\n", rt_tick_get());
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 5)
|
|
||||||
{
|
|
||||||
rt_kprintf("[%d] thread29, init_priority=%d, current_priority=%d\n",
|
|
||||||
rt_tick_get(), tid29->init_priority, tid29->current_priority);
|
|
||||||
}
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_kprintf("[%d] thread29 exit!\n", rt_tick_get());
|
|
||||||
}
|
|
||||||
|
|
||||||
static int mutex_simple_init()
|
|
||||||
{
|
|
||||||
/* 创建互斥锁 */
|
|
||||||
mutex = rt_mutex_create("mutex", RT_IPC_FLAG_PRIO);
|
|
||||||
if (mutex == RT_NULL)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
tid29 = rt_thread_create("t29",
|
|
||||||
thread29_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 29, THREAD_TIMESLICE);
|
|
||||||
if (tid29 != RT_NULL)
|
|
||||||
rt_thread_startup(tid29);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid28 = rt_thread_create("t28",
|
|
||||||
thread28_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 28, THREAD_TIMESLICE);
|
|
||||||
if (tid28 != RT_NULL)
|
|
||||||
rt_thread_startup(tid28);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid27 = rt_thread_create("t27",
|
|
||||||
thread27_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 27, THREAD_TIMESLICE);
|
|
||||||
if (tid27 != RT_NULL)
|
|
||||||
rt_thread_startup(tid27);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid26 = rt_thread_create("t26",
|
|
||||||
thread26_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 26, THREAD_TIMESLICE);
|
|
||||||
if (tid26 != RT_NULL)
|
|
||||||
rt_thread_startup(tid26);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid25 = rt_thread_create("t25",
|
|
||||||
thread25_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 25, THREAD_TIMESLICE);
|
|
||||||
if (tid25 != RT_NULL)
|
|
||||||
rt_thread_startup(tid25);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid24 = rt_thread_create("t24",
|
|
||||||
thread24_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 24, THREAD_TIMESLICE);
|
|
||||||
if (tid24 != RT_NULL)
|
|
||||||
rt_thread_startup(tid24);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid23 = rt_thread_create("t23",
|
|
||||||
thread23_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 23, THREAD_TIMESLICE);
|
|
||||||
if (tid23 != RT_NULL)
|
|
||||||
rt_thread_startup(tid23);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid22 = rt_thread_create("t22",
|
|
||||||
thread22_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 22, THREAD_TIMESLICE);
|
|
||||||
if (tid22 != RT_NULL)
|
|
||||||
rt_thread_startup(tid22);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid21 = rt_thread_create("t21",
|
|
||||||
thread21_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 21, THREAD_TIMESLICE);
|
|
||||||
if (tid21 != RT_NULL)
|
|
||||||
rt_thread_startup(tid21);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
tid20 = rt_thread_create("t20",
|
|
||||||
thread20_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, 20, THREAD_TIMESLICE);
|
|
||||||
if (tid20 != RT_NULL)
|
|
||||||
rt_thread_startup(tid20);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid20 != RT_NULL && tid20->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid20);
|
|
||||||
if (tid21 != RT_NULL && tid21->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid21);
|
|
||||||
if (tid22 != RT_NULL && tid22->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid22);
|
|
||||||
if (tid23 != RT_NULL && tid23->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid23);
|
|
||||||
if (tid24 != RT_NULL && tid24->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid24);
|
|
||||||
if (tid25 != RT_NULL && tid25->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid25);
|
|
||||||
if (tid26 != RT_NULL && tid26->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid26);
|
|
||||||
if (tid27 != RT_NULL && tid27->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid27);
|
|
||||||
if (tid28 != RT_NULL && tid28->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid28);
|
|
||||||
if (tid29 != RT_NULL && tid29->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid29);
|
|
||||||
|
|
||||||
if (mutex != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_mutex_delete(mutex);
|
|
||||||
}
|
|
||||||
rt_kprintf("test_done!\n");
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_mutex_priority()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
mutex_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_mutex_priority, a priority rollover example of mutex);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
mutex_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,172 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
static rt_thread_t tid3 = RT_NULL;
|
|
||||||
static rt_mutex_t mutex = RT_NULL;
|
|
||||||
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 先让低优先级线程运行 */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* 此时thread3持有mutex，并且thread2等待持有mutex */
|
|
||||||
|
|
||||||
/* 检查thread2与thread3的优先级情况 */
|
|
||||||
if (tid2->current_priority != tid3->current_priority)
|
|
||||||
{
|
|
||||||
/* 优先级不相同，测试失败 */
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* 先让低优先级线程运行 */
|
|
||||||
rt_thread_delay(5);
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* 试图持有互斥锁，此时thread3持有，应把thread3的优先级提升到thread2相同
|
|
||||||
* 的优先级
|
|
||||||
*/
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
{
|
|
||||||
/* 释放互斥锁 */
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程3入口 */
|
|
||||||
static void thread3_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
result = rt_mutex_take(mutex, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 做一个长时间的循环，总共50个OS Tick */
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (rt_tick_get() - tick < 50) ;
|
|
||||||
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
rt_mutex_release(mutex);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int mutex_simple_init()
|
|
||||||
{
|
|
||||||
/* 创建互斥锁 */
|
|
||||||
mutex = rt_mutex_create("mutex", RT_IPC_FLAG_PRIO);
|
|
||||||
if (mutex == RT_NULL)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程3 */
|
|
||||||
tid3 = rt_thread_create("t3",
|
|
||||||
thread3_entry, RT_NULL, /* 线程入口是thread3_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
|
|
||||||
if (tid3 != RT_NULL)
|
|
||||||
rt_thread_startup(tid3);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
if (tid3 != RT_NULL && tid3->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid3);
|
|
||||||
|
|
||||||
if (mutex != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_mutex_delete(mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_mutex_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
mutex_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_mutex_simple, sime mutex example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
mutex_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,282 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：信号量实现生产者消费者间的互斥
|
|
||||||
*
|
|
||||||
* 在这个程序中，会创建两个线程，一个是生成者线程worker一个是消费者线程thread
|
|
||||||
*
|
|
||||||
* 在数据信息生产、消费的过程中，worker负责把数据将写入到环形buffer中，而thread
|
|
||||||
* 则从环形buffer中读出。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 一个环形buffer的实现 */
|
|
||||||
struct rb
|
|
||||||
{
|
|
||||||
rt_uint16_t read_index, write_index;
|
|
||||||
rt_uint8_t *buffer_ptr;
|
|
||||||
rt_uint16_t buffer_size;
|
|
||||||
};
|
|
||||||
|
|
||||||
/* 指向信号量控制块的指针 */
|
|
||||||
static rt_sem_t sem = RT_NULL;
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid = RT_NULL, worker = RT_NULL;
|
|
||||||
|
|
||||||
/* 环形buffer的内存块（用数组体现出来） */
|
|
||||||
#define BUFFER_SIZE 256
|
|
||||||
#define BUFFER_ITEM 32
|
|
||||||
static rt_uint8_t working_buffer[BUFFER_SIZE];
|
|
||||||
struct rb working_rb;
|
|
||||||
|
|
||||||
/* 初始化环形buffer，size指的是buffer的大小。注：这里并没对数据地址对齐做处理 */
|
|
||||||
static void rb_init(struct rb* rb, rt_uint8_t *pool, rt_uint16_t size)
|
|
||||||
{
|
|
||||||
RT_ASSERT(rb != RT_NULL);
|
|
||||||
|
|
||||||
/* 对读写指针清零*/
|
|
||||||
rb->read_index = rb->write_index = 0;
|
|
||||||
|
|
||||||
/* 设置环形buffer的内存数据块 */
|
|
||||||
rb->buffer_ptr = pool;
|
|
||||||
rb->buffer_size = size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 向环形buffer中写入数据 */
|
|
||||||
static rt_bool_t rb_put(struct rb* rb, const rt_uint8_t *ptr, rt_uint16_t length)
|
|
||||||
{
|
|
||||||
rt_size_t size;
|
|
||||||
|
|
||||||
/* 判断是否有足够的剩余空间 */
|
|
||||||
if (rb->read_index > rb->write_index)
|
|
||||||
size = rb->read_index - rb->write_index;
|
|
||||||
else
|
|
||||||
size = rb->buffer_size - rb->write_index + rb->read_index;
|
|
||||||
|
|
||||||
/* 没有多余的空间 */
|
|
||||||
if (size < length) return RT_FALSE;
|
|
||||||
|
|
||||||
if (rb->read_index > rb->write_index)
|
|
||||||
{
|
|
||||||
/* read_index - write_index 即为总的空余空间 */
|
|
||||||
memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
|
|
||||||
rb->write_index += length;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
if (rb->buffer_size - rb->write_index > length)
|
|
||||||
{
|
|
||||||
/* write_index 后面剩余的空间有足够的长度 */
|
|
||||||
memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
|
|
||||||
rb->write_index += length;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* write_index 后面剩余的空间不存在足够的长度，需要把部分数据复制到
|
|
||||||
* 前面的剩余空间中
|
|
||||||
*/
|
|
||||||
memcpy(&rb->buffer_ptr[rb->write_index], ptr,
|
|
||||||
rb->buffer_size - rb->write_index);
|
|
||||||
memcpy(&rb->buffer_ptr[0], &ptr[rb->buffer_size - rb->write_index],
|
|
||||||
length - (rb->buffer_size - rb->write_index));
|
|
||||||
rb->write_index = length - (rb->buffer_size - rb->write_index);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return RT_TRUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 从环形buffer中读出数据 */
|
|
||||||
static rt_bool_t rb_get(struct rb* rb, rt_uint8_t *ptr, rt_uint16_t length)
|
|
||||||
{
|
|
||||||
rt_size_t size;
|
|
||||||
|
|
||||||
/* 判断是否有足够的数据 */
|
|
||||||
if (rb->read_index > rb->write_index)
|
|
||||||
size = rb->buffer_size - rb->read_index + rb->write_index;
|
|
||||||
else
|
|
||||||
size = rb->write_index - rb->read_index;
|
|
||||||
|
|
||||||
/* 没有足够的数据 */
|
|
||||||
if (size < length) return RT_FALSE;
|
|
||||||
|
|
||||||
if (rb->read_index > rb->write_index)
|
|
||||||
{
|
|
||||||
if (rb->buffer_size - rb->read_index > length)
|
|
||||||
{
|
|
||||||
/* read_index的数据足够多，直接复制 */
|
|
||||||
memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
|
|
||||||
rb->read_index += length;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* read_index的数据不够，需要分段复制 */
|
|
||||||
memcpy(ptr, &rb->buffer_ptr[rb->read_index],
|
|
||||||
rb->buffer_size - rb->read_index);
|
|
||||||
memcpy(&ptr[rb->buffer_size - rb->read_index], &rb->buffer_ptr[0],
|
|
||||||
length - rb->buffer_size + rb->read_index);
|
|
||||||
rb->read_index = length - rb->buffer_size + rb->read_index;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* read_index要比write_index小，总的数据量够（前面已经有总数据量的判
|
|
||||||
* 断），直接复制出数据。
|
|
||||||
*/
|
|
||||||
memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
|
|
||||||
rb->read_index += length;
|
|
||||||
}
|
|
||||||
|
|
||||||
return RT_TRUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 生产者线程入口 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_bool_t result;
|
|
||||||
rt_uint8_t data_buffer[BUFFER_ITEM + 1];
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 持有信号量 */
|
|
||||||
rt_sem_take(sem, RT_WAITING_FOREVER);
|
|
||||||
/* 从环buffer中获得数据 */
|
|
||||||
result = rb_get(&working_rb, &data_buffer[0], BUFFER_ITEM);
|
|
||||||
/* 释放信号量 */
|
|
||||||
rt_sem_release(sem);
|
|
||||||
data_buffer[BUFFER_ITEM] = '\0';
|
|
||||||
|
|
||||||
if (result == RT_TRUE)
|
|
||||||
{
|
|
||||||
/* 获取数据成功，打印数据 */
|
|
||||||
rt_kprintf("%s\n", data_buffer);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 做一个5 OS Tick的休眠 */
|
|
||||||
rt_thread_delay(5);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* worker线程入口 */
|
|
||||||
static void worker_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_bool_t result;
|
|
||||||
rt_uint32_t index, setchar;
|
|
||||||
rt_uint8_t data_buffer[BUFFER_ITEM];
|
|
||||||
|
|
||||||
setchar = 0x21;
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 构造数据 */
|
|
||||||
for(index = 0; index < BUFFER_ITEM; index++)
|
|
||||||
{
|
|
||||||
data_buffer[index] = setchar;
|
|
||||||
if (++setchar == 0x7f)
|
|
||||||
setchar = 0x21;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 持有信号量 */
|
|
||||||
rt_sem_take(sem, RT_WAITING_FOREVER);
|
|
||||||
|
|
||||||
/* 把数据放到环形buffer中 */
|
|
||||||
result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM);
|
|
||||||
if (result == RT_FALSE)
|
|
||||||
{
|
|
||||||
rt_kprintf("put error\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 释放信号量 */
|
|
||||||
rt_sem_release(sem);
|
|
||||||
|
|
||||||
/* 放入成功，做一个10 OS Tick的休眠 */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int semaphore_buffer_worker_init()
|
|
||||||
{
|
|
||||||
/* 初始化ring buffer */
|
|
||||||
rb_init(&working_rb, working_buffer, BUFFER_SIZE);
|
|
||||||
|
|
||||||
/* 创建信号量 */
|
|
||||||
sem = rt_sem_create("sem", 1, RT_IPC_FLAG_PRIO);
|
|
||||||
if (sem == RT_NULL)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid = rt_thread_create("thread",
|
|
||||||
thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
rt_thread_startup(tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
worker = rt_thread_create("worker",
|
|
||||||
worker_entry, RT_NULL, /* 线程入口是worker_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (worker != RT_NULL)
|
|
||||||
rt_thread_startup(worker);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除信号量 */
|
|
||||||
if (sem != RT_NULL)
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid);
|
|
||||||
if (worker != RT_NULL && worker->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(worker);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_semaphore_buffer_worker()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
semaphore_buffer_worker_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_semaphore_buffer_worker, a buffer worker with semaphore example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
semaphore_buffer_worker_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,144 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：动态信号量
|
|
||||||
*
|
|
||||||
* 这个例子中将创建一个动态信号量（初始值为0 ）及一个动态线程，在这个动态线程中
|
|
||||||
* 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并
|
|
||||||
* 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid = RT_NULL;
|
|
||||||
/* 指向信号量的指针 */
|
|
||||||
static rt_sem_t sem = RT_NULL;
|
|
||||||
/* 线程入口 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
/* 获得当前的OS Tick */
|
|
||||||
tick = rt_tick_get();
|
|
||||||
|
|
||||||
/* 试图持有一个信号量，如果10个OS Tick依然没拿到，则超时返回 */
|
|
||||||
result = rt_sem_take(sem, 10);
|
|
||||||
if (result == -RT_ETIMEOUT)
|
|
||||||
{
|
|
||||||
rt_tick_t new_tick = rt_tick_get();
|
|
||||||
/* 可以有两个 tick 的误差 */
|
|
||||||
if (new_tick - tick >= 12)
|
|
||||||
{
|
|
||||||
rt_kprintf("tick error to large: expect: 10, get %d\n",
|
|
||||||
new_tick - tick);
|
|
||||||
|
|
||||||
/* 如果失败，则测试失败 */
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
rt_kprintf("take semaphore timeout\n");
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* 因为并没释放信号量，应该是超时返回，否则测试失败 */
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 释放一次信号量 */
|
|
||||||
rt_sem_release(sem);
|
|
||||||
|
|
||||||
/* 继续持有信号量，并永远等待直到持有到信号量 */
|
|
||||||
result = rt_sem_take(sem, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
/* 返回不正确，测试失败 */
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 测试成功 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
/* 删除信号量 */
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
}
|
|
||||||
|
|
||||||
int semaphore_dynamic_init()
|
|
||||||
{
|
|
||||||
/* 创建一个信号量，初始值是0 */
|
|
||||||
sem = rt_sem_create("sem", 0, RT_IPC_FLAG_PRIO);
|
|
||||||
if (sem == RT_NULL)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 创建线程 */
|
|
||||||
tid = rt_thread_create("thread",
|
|
||||||
thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
rt_thread_startup(tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
if (sem)
|
|
||||||
{
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
sem = RT_NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
|
|
||||||
{
|
|
||||||
rt_thread_delete(tid);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_semaphore_dynamic()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
semaphore_dynamic_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_semaphore_dynamic, a dynamic semaphore example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
semaphore_dynamic_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,143 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static rt_sem_t sem;
|
|
||||||
static rt_uint8_t t1_count, t2_count;
|
|
||||||
static rt_thread_t t1, t2, worker;
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
result = rt_sem_take(sem, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
t1_count ++;
|
|
||||||
rt_kprintf("thread1: got semaphore, count: %d\n", t1_count);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
result = rt_sem_take(sem, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
t2_count ++;
|
|
||||||
rt_kprintf("thread2: got semaphore, count: %d\n", t2_count);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void worker_thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_sem_release(sem);
|
|
||||||
rt_thread_delay(5);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int semaphore_priority_init()
|
|
||||||
{
|
|
||||||
sem = rt_sem_create("sem", 0, RT_IPC_FLAG_PRIO);
|
|
||||||
if (sem == RT_NULL)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
t1_count = t2_count = 0;
|
|
||||||
|
|
||||||
t1 = rt_thread_create("t1",
|
|
||||||
thread1_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
|
|
||||||
if (t1 != RT_NULL)
|
|
||||||
rt_thread_startup(t1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
t2 = rt_thread_create("t2",
|
|
||||||
thread2_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (t2 != RT_NULL)
|
|
||||||
rt_thread_startup(t2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
worker = rt_thread_create("worker",
|
|
||||||
worker_thread_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (worker != RT_NULL)
|
|
||||||
rt_thread_startup(worker);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* delete t1, t2 and worker thread */
|
|
||||||
rt_thread_delete(t1);
|
|
||||||
rt_thread_delete(t2);
|
|
||||||
rt_thread_delete(worker);
|
|
||||||
|
|
||||||
if (sem)
|
|
||||||
{
|
|
||||||
rt_sem_delete(sem);
|
|
||||||
sem = RT_NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (t1_count > t2_count)
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
else
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_semaphore_priority()
|
|
||||||
{
|
|
||||||
/* set tc cleanup */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
semaphore_priority_init();
|
|
||||||
|
|
||||||
return 50;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_semaphore_priority, a priority semaphore test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
semaphore_priority_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,168 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：生产者消费者例子
|
|
||||||
*
|
|
||||||
* 这个例子中将创建两个线程用于实现生产者消费者问题
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 定义最大5个元素能够被产生 */
|
|
||||||
#define MAXSEM 5
|
|
||||||
|
|
||||||
/* 用于放置生产的整数数组 */
|
|
||||||
rt_uint32_t array[MAXSEM];
|
|
||||||
/* 指向生产者、消费者在array数组中的读写位置 */
|
|
||||||
static rt_uint32_t set, get;
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t producer_tid = RT_NULL;
|
|
||||||
static rt_thread_t consumer_tid = RT_NULL;
|
|
||||||
|
|
||||||
struct rt_semaphore sem_lock;
|
|
||||||
struct rt_semaphore sem_empty, sem_full;
|
|
||||||
|
|
||||||
/* 生成者线程入口 */
|
|
||||||
void producer_thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
int cnt = 0;
|
|
||||||
|
|
||||||
/* 运行100次 */
|
|
||||||
while( cnt < 100)
|
|
||||||
{
|
|
||||||
/* 获取一个空位 */
|
|
||||||
rt_sem_take(&sem_empty, RT_WAITING_FOREVER);
|
|
||||||
|
|
||||||
/* 修改array内容，上锁 */
|
|
||||||
rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
|
|
||||||
array[set%MAXSEM] = cnt + 1;
|
|
||||||
rt_kprintf("the producer generates a number: %d\n", array[set%MAXSEM]);
|
|
||||||
set++;
|
|
||||||
rt_sem_release(&sem_lock);
|
|
||||||
|
|
||||||
/* 发布一个满位 */
|
|
||||||
rt_sem_release(&sem_full);
|
|
||||||
cnt++;
|
|
||||||
|
|
||||||
/* 暂停一段时间 */
|
|
||||||
rt_thread_delay(50);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_kprintf("the producer exit!\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 消费者线程入口 */
|
|
||||||
void consumer_thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t no;
|
|
||||||
rt_uint32_t sum;
|
|
||||||
|
|
||||||
/* 第n个线程，由入口参数传进来 */
|
|
||||||
no = (rt_uint32_t)parameter;
|
|
||||||
|
|
||||||
sum = 0;
|
|
||||||
while(1)
|
|
||||||
{
|
|
||||||
/* 获取一个满位 */
|
|
||||||
rt_sem_take(&sem_full, RT_WAITING_FOREVER);
|
|
||||||
|
|
||||||
/* 临界区，上锁进行操作 */
|
|
||||||
rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
|
|
||||||
sum += array[get%MAXSEM];
|
|
||||||
rt_kprintf("the consumer[%d] get a number: %d\n", no, array[get%MAXSEM] );
|
|
||||||
get++;
|
|
||||||
rt_sem_release(&sem_lock);
|
|
||||||
|
|
||||||
/* 释放一个空位 */
|
|
||||||
rt_sem_release(&sem_empty);
|
|
||||||
|
|
||||||
/* 生产者生产到100个数目，停止，消费者线程相应停止 */
|
|
||||||
if (get == 100) break;
|
|
||||||
|
|
||||||
/* 暂停一小会时间 */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_kprintf("the consumer[%d] sum is %d \n ", no, sum);
|
|
||||||
rt_kprintf("the consumer[%d] exit!\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
int semaphore_producer_consumer_init()
|
|
||||||
{
|
|
||||||
/* 初始化3个信号量 */
|
|
||||||
rt_sem_init(&sem_lock , "lock", 1, RT_IPC_FLAG_PRIO);
|
|
||||||
rt_sem_init(&sem_empty, "empty", MAXSEM, RT_IPC_FLAG_PRIO);
|
|
||||||
rt_sem_init(&sem_full , "full", 0, RT_IPC_FLAG_PRIO);
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
producer_tid = rt_thread_create("producer",
|
|
||||||
producer_thread_entry, RT_NULL, /* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (producer_tid != RT_NULL)
|
|
||||||
rt_thread_startup(producer_tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
consumer_tid = rt_thread_create("consumer",
|
|
||||||
consumer_thread_entry, RT_NULL, /* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
|
|
||||||
if (consumer_tid != RT_NULL)
|
|
||||||
rt_thread_startup(consumer_tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
rt_sem_detach(&sem_lock);
|
|
||||||
rt_sem_detach(&sem_empty);
|
|
||||||
rt_sem_detach(&sem_full);
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (producer_tid != RT_NULL && producer_tid->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(producer_tid);
|
|
||||||
if (consumer_tid != RT_NULL && consumer_tid->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(consumer_tid);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_semaphore_producer_consumer()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
semaphore_producer_consumer_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_semaphore_producer_consumer, producer and consumer example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
semaphore_producer_consumer_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,145 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：静态信号量
|
|
||||||
*
|
|
||||||
* 这个例子中将创建一个静态信号量（初始值为0 ）及一个静态线程，在这个静态线程中
|
|
||||||
* 将试图采用超时方式去持有信号量，应该超时返回。然后这个线程释放一次信号量，并
|
|
||||||
* 在后面继续采用永久等待方式去持有信号量， 成功获得信号量后返回。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 线程控制块及栈 */
|
|
||||||
static struct rt_thread thread;
|
|
||||||
static rt_uint8_t thread_stack[THREAD_STACK_SIZE];
|
|
||||||
/* 信号量控制块 */
|
|
||||||
static struct rt_semaphore sem;
|
|
||||||
|
|
||||||
/* 线程入口 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
/* 获得当前的OS Tick */
|
|
||||||
tick = rt_tick_get();
|
|
||||||
|
|
||||||
/* 试图持有信号量，最大等待10个OS Tick后返回 */
|
|
||||||
result = rt_sem_take(&sem, 10);
|
|
||||||
if (result == -RT_ETIMEOUT)
|
|
||||||
{
|
|
||||||
rt_tick_t new_tick = rt_tick_get();
|
|
||||||
/* 可以有两个 tick 的误差 */
|
|
||||||
if (new_tick - tick >= 12)
|
|
||||||
{
|
|
||||||
rt_kprintf("tick error to large: expect: 10, get %d\n",
|
|
||||||
new_tick - tick);
|
|
||||||
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_detach(&sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
rt_kprintf("take semaphore timeout\n");
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* 因为没有其他地方是否信号量，所以不应该成功持有信号量，否则测试失败 */
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_detach(&sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 释放一次信号量 */
|
|
||||||
rt_sem_release(&sem);
|
|
||||||
|
|
||||||
/* 永久等待方式持有信号量 */
|
|
||||||
result = rt_sem_take(&sem, RT_WAITING_FOREVER);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
/* 不成功则测试失败 */
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
rt_sem_detach(&sem);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 测试通过 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
/* 脱离信号量对象 */
|
|
||||||
rt_sem_detach(&sem);
|
|
||||||
}
|
|
||||||
|
|
||||||
int semaphore_static_init(void)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* 初始化信号量，初始值是0 */
|
|
||||||
result = rt_sem_init(&sem, "sem", 0, RT_IPC_FLAG_PRIO);
|
|
||||||
if (result != RT_EOK)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 初始化线程1 */
|
|
||||||
result = rt_thread_init(&thread, "thread", /* 线程名：thread */
|
|
||||||
thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是RT_NULL*/
|
|
||||||
&thread_stack[0], sizeof(thread_stack), /* 线程栈是thread_stack */
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
if (result == RT_EOK) /* 如果返回正确，启动线程1 */
|
|
||||||
rt_thread_startup(&thread);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup(void)
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 执行线程脱离 */
|
|
||||||
if (thread.stat != RT_THREAD_CLOSE)
|
|
||||||
{
|
|
||||||
rt_thread_detach(&thread);
|
|
||||||
|
|
||||||
/* 执行信号量对象脱离 */
|
|
||||||
rt_sem_detach(&sem);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_semaphore_static(void)
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
semaphore_static_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_semaphore_static, a static semaphore example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init(void)
|
|
||||||
{
|
|
||||||
semaphore_static_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,206 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "tc_comm.h"
|
|
||||||
#ifdef RT_USING_FINSH
|
|
||||||
#include <finsh.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
#define TC_PRIORITY 25
|
|
||||||
#define TC_STACK_SIZE 0x400
|
|
||||||
|
|
||||||
static rt_uint8_t _tc_stat;
|
|
||||||
static struct rt_semaphore _tc_sem;
|
|
||||||
static struct rt_thread _tc_thread;
|
|
||||||
static rt_uint8_t _tc_stack[TC_STACK_SIZE];
|
|
||||||
static char _tc_prefix[64];
|
|
||||||
static const char* _tc_current;
|
|
||||||
static void (*_tc_cleanup)(void) = RT_NULL;
|
|
||||||
|
|
||||||
static rt_uint32_t _tc_scale = 1;
|
|
||||||
|
|
||||||
static rt_uint32_t _tc_loop;
|
|
||||||
|
|
||||||
void tc_thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
unsigned int fail_count = 0;
|
|
||||||
struct finsh_syscall* index;
|
|
||||||
|
|
||||||
/* create tc semaphore */
|
|
||||||
rt_sem_init(&_tc_sem, "tc", 0, RT_IPC_FLAG_PRIO);
|
|
||||||
|
|
||||||
do {
|
|
||||||
for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))
|
|
||||||
{
|
|
||||||
/* search testcase */
|
|
||||||
if (rt_strstr(index->name, _tc_prefix) == index->name)
|
|
||||||
{
|
|
||||||
long tick;
|
|
||||||
|
|
||||||
_tc_current = index->name + 4;
|
|
||||||
rt_kprintf("Run TestCase: %s\n", _tc_current);
|
|
||||||
_tc_stat = TC_STAT_PASSED | TC_STAT_RUNNING;
|
|
||||||
tick = index->func();
|
|
||||||
if (tick > 0)
|
|
||||||
{
|
|
||||||
/* Make sure we are going to be blocked. */
|
|
||||||
rt_sem_control(&_tc_sem, RT_IPC_CMD_RESET, 0);
|
|
||||||
rt_sem_take(&_tc_sem, tick * _tc_scale);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (_tc_cleanup != RT_NULL)
|
|
||||||
{
|
|
||||||
/* perform testcase cleanup */
|
|
||||||
_tc_cleanup();
|
|
||||||
_tc_cleanup = RT_NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (_tc_stat & TC_STAT_RUNNING)
|
|
||||||
{
|
|
||||||
rt_kprintf("TestCase[%s] exit with stat TC_STAT_RUNNING."
|
|
||||||
" Please fix the TC.\n",
|
|
||||||
_tc_current);
|
|
||||||
/* If the TC forgot to clear the flag, we do it. */
|
|
||||||
_tc_stat &= ~TC_STAT_RUNNING;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (_tc_stat & TC_STAT_FAILED)
|
|
||||||
{
|
|
||||||
rt_kprintf("TestCase[%s] failed\n", _tc_current);
|
|
||||||
fail_count++;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
rt_kprintf("TestCase[%s] passed\n", _tc_current);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} while (_tc_loop);
|
|
||||||
|
|
||||||
rt_kprintf("RT-Thread TestCase Running Done!\n");
|
|
||||||
if (fail_count)
|
|
||||||
{
|
|
||||||
rt_kprintf("%d tests failed\n", fail_count);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
rt_kprintf("All tests passed\n");
|
|
||||||
}
|
|
||||||
/* detach tc semaphore */
|
|
||||||
rt_sem_detach(&_tc_sem);
|
|
||||||
}
|
|
||||||
|
|
||||||
void tc_stop()
|
|
||||||
{
|
|
||||||
_tc_loop = 0;
|
|
||||||
|
|
||||||
rt_thread_delay(10 * RT_TICK_PER_SECOND);
|
|
||||||
if (_tc_thread.stat != RT_THREAD_INIT)
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* detach old tc thread */
|
|
||||||
rt_thread_detach(&_tc_thread);
|
|
||||||
rt_sem_detach(&_tc_sem);
|
|
||||||
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
rt_thread_delay(RT_TICK_PER_SECOND/2);
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(tc_stop, stop testcase thread);
|
|
||||||
|
|
||||||
void tc_done(rt_uint8_t stat)
|
|
||||||
{
|
|
||||||
_tc_stat |= stat;
|
|
||||||
_tc_stat &= ~TC_STAT_RUNNING;
|
|
||||||
|
|
||||||
/* release semaphore */
|
|
||||||
rt_sem_release(&_tc_sem);
|
|
||||||
}
|
|
||||||
|
|
||||||
void tc_stat(rt_uint8_t stat)
|
|
||||||
{
|
|
||||||
if (stat & TC_STAT_FAILED)
|
|
||||||
{
|
|
||||||
rt_kprintf("TestCases[%s] failed\n", _tc_current);
|
|
||||||
}
|
|
||||||
_tc_stat |= stat;
|
|
||||||
}
|
|
||||||
|
|
||||||
void tc_cleanup(void (*cleanup)())
|
|
||||||
{
|
|
||||||
_tc_cleanup = cleanup;
|
|
||||||
}
|
|
||||||
|
|
||||||
void tc_start(const char* tc_prefix)
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* tesecase prefix is null */
|
|
||||||
if (tc_prefix == RT_NULL)
|
|
||||||
{
|
|
||||||
rt_kprintf("TestCase Usage: tc_start(prefix)\n\n");
|
|
||||||
rt_kprintf("list_tc() can list all testcases.\n");
|
|
||||||
return ;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* init tc thread */
|
|
||||||
if (_tc_stat & TC_STAT_RUNNING)
|
|
||||||
{
|
|
||||||
/* stop old tc thread */
|
|
||||||
tc_stop();
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_memset(_tc_prefix, 0, sizeof(_tc_prefix));
|
|
||||||
rt_snprintf(_tc_prefix, sizeof(_tc_prefix), "_tc_%s", tc_prefix);
|
|
||||||
|
|
||||||
result = rt_thread_init(&_tc_thread, "tc",
|
|
||||||
tc_thread_entry, RT_NULL,
|
|
||||||
&_tc_stack[0], sizeof(_tc_stack),
|
|
||||||
TC_PRIORITY - 3, 5);
|
|
||||||
|
|
||||||
/* set tc stat */
|
|
||||||
_tc_stat = TC_STAT_RUNNING | TC_STAT_FAILED;
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&_tc_thread);
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(tc_start, start testcase with testcase prefix or name);
|
|
||||||
|
|
||||||
void tc_loop(const char *tc_prefix)
|
|
||||||
{
|
|
||||||
_tc_loop = 1;
|
|
||||||
tc_start(tc_prefix);
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(tc_loop, start testcase with testcase prefix or name in loop mode);
|
|
||||||
|
|
||||||
void list_tc()
|
|
||||||
{
|
|
||||||
struct finsh_syscall* index;
|
|
||||||
|
|
||||||
rt_kprintf("TestCases List:\n");
|
|
||||||
for (index = _syscall_table_begin; index < _syscall_table_end; FINSH_NEXT_SYSCALL(index))
|
|
||||||
{
|
|
||||||
/* search testcase */
|
|
||||||
if (rt_strstr(index->name, "_tc_") == index->name)
|
|
||||||
{
|
|
||||||
#ifdef FINSH_USING_DESCRIPTION
|
|
||||||
rt_kprintf("%-16s -- %s\n", index->name + 4, index->desc);
|
|
||||||
#else
|
|
||||||
rt_kprintf("%s\n", index->name + 4);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(list_tc, list all testcases);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,52 +0,0 @@
|
||||||
|
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
#ifndef __TC_COMM_H__
|
|
||||||
#define __TC_COMM_H__
|
|
||||||
|
|
||||||
/*
|
|
||||||
* RT-Thread TestCase
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#ifdef RT_USING_FINSH
|
|
||||||
#include <finsh.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if RT_THREAD_PRIORITY_MAX == 8
|
|
||||||
#define THREAD_PRIORITY 6
|
|
||||||
#elif RT_THREAD_PRIORITY_MAX == 32
|
|
||||||
#define THREAD_PRIORITY 25
|
|
||||||
#elif RT_THREAD_PRIORITY_MAX == 256
|
|
||||||
#define THREAD_PRIORITY 200
|
|
||||||
#endif
|
|
||||||
#define THREAD_STACK_SIZE 512
|
|
||||||
#define THREAD_TIMESLICE 5
|
|
||||||
|
|
||||||
#define TC_STAT_END 0x00
|
|
||||||
#define TC_STAT_RUNNING 0x01
|
|
||||||
#define TC_STAT_FAILED 0x10
|
|
||||||
#define TC_STAT_PASSED 0x00
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
void tc_start(const char* tc_prefix);
|
|
||||||
void tc_stop(void);
|
|
||||||
void tc_done(rt_uint8_t state);
|
|
||||||
void tc_stat(rt_uint8_t state);
|
|
||||||
void tc_cleanup(void (*cleanup)(void));
|
|
||||||
#else
|
|
||||||
#define tc_start(x)
|
|
||||||
#define tc_stop()
|
|
||||||
#define tc_done(s)
|
|
||||||
#define tc_stat(s)
|
|
||||||
#define tc_cleanup(c)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,71 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static rt_thread_t tid = RT_NULL;
|
|
||||||
static void sample_thread(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("I'm sample!\n");
|
|
||||||
}
|
|
||||||
static void sample_thread_cleanup(struct rt_thread *p)
|
|
||||||
{
|
|
||||||
tid = RT_NULL;
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int sample_init()
|
|
||||||
{
|
|
||||||
tid = rt_thread_create("t",
|
|
||||||
sample_thread, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_thread_startup(tid);
|
|
||||||
tid->cleanup = sample_thread_cleanup;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
/* delete thread */
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_kprintf("tid1 is bad\n");
|
|
||||||
tc_stat(TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_sample()
|
|
||||||
{
|
|
||||||
/* set tc cleanup */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
sample_init();
|
|
||||||
|
|
||||||
return 25;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_sample, a thread testcase example);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
sample_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,79 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is an example for delay thread
|
|
||||||
*/
|
|
||||||
static struct rt_thread thread;
|
|
||||||
static char thread_stack[THREAD_STACK_SIZE];
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
rt_kprintf("thread inited ok\n");
|
|
||||||
|
|
||||||
rt_kprintf("thread delay 10 tick\n");
|
|
||||||
tick = rt_tick_get();
|
|
||||||
rt_thread_delay(10);
|
|
||||||
if (rt_tick_get() - tick > 11)
|
|
||||||
{
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_kprintf("thread delay 15 tick\n");
|
|
||||||
tick = rt_tick_get();
|
|
||||||
rt_thread_delay(15);
|
|
||||||
if (rt_tick_get() - tick > 16)
|
|
||||||
{
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_kprintf("thread exit\n");
|
|
||||||
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_err_t thread_delay_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
result = rt_thread_init(&thread,
|
|
||||||
"test",
|
|
||||||
thread_entry, RT_NULL,
|
|
||||||
&thread_stack[0], sizeof(thread_stack),
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
int _tc_thread_delay()
|
|
||||||
{
|
|
||||||
thread_delay_init();
|
|
||||||
|
|
||||||
return 30;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_delay, a thread delay test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_delay_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,151 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：删除线程
|
|
||||||
*
|
|
||||||
* 这个例子会创建两个线程，在一个线程中删除另外一个线程。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程删除(rt_thread_delete)函数仅适合于动态线程，为了在一个线程
|
|
||||||
* 中访问另一个线程的控制块，所以把线程块指针声明成全局类型以供全
|
|
||||||
* 局访问
|
|
||||||
*/
|
|
||||||
static rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;
|
|
||||||
/* 线程1的入口函数 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 线程1采用低优先级运行，一直打印计数值 */
|
|
||||||
// rt_kprintf("thread count: %d\n", count ++);
|
|
||||||
count ++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
static void thread1_cleanup(struct rt_thread *tid)
|
|
||||||
{
|
|
||||||
if (tid != tid1)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return ;
|
|
||||||
}
|
|
||||||
rt_kprintf("thread1 end\n");
|
|
||||||
tid1 = RT_NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2的入口函数 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
|
|
||||||
|
|
||||||
/* 线程2启动后先睡眠10个OS Tick */
|
|
||||||
rt_thread_delay(RT_TICK_PER_SECOND);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程2唤醒后直接删除线程1，删除线程1后，线程1自动脱离就绪线程
|
|
||||||
* 队列
|
|
||||||
*/
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程2继续休眠10个OS Tick然后退出，线程2休眠后应切换到idle线程
|
|
||||||
* idle线程将执行真正的线程1控制块和线程栈的删除
|
|
||||||
*/
|
|
||||||
rt_thread_delay(RT_TICK_PER_SECOND);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread2_cleanup(struct rt_thread *tid)
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* 线程2运行结束后也将自动被删除(线程控制块和线程栈在idle线
|
|
||||||
* 程中释放)
|
|
||||||
*/
|
|
||||||
|
|
||||||
if (tid != tid2)
|
|
||||||
{
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
return ;
|
|
||||||
}
|
|
||||||
rt_kprintf("thread2 end\n");
|
|
||||||
tid2 = RT_NULL;
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程删除示例的初始化 */
|
|
||||||
int thread_delete_init()
|
|
||||||
{
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1", /* 线程1的名称是t1 */
|
|
||||||
thread1_entry, RT_NULL, /* 入口是thread1_entry，参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */
|
|
||||||
{
|
|
||||||
tid1->cleanup = thread1_cleanup;
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid2 = rt_thread_create("t2", /* 线程1的名称是t2 */
|
|
||||||
thread2_entry, RT_NULL, /* 入口是thread2_entry，参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL) /* 如果获得线程控制块，启动这个线程 */
|
|
||||||
{
|
|
||||||
tid2->cleanup = thread2_cleanup;
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 10 * RT_TICK_PER_SECOND;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* delete thread */
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_kprintf("tid1 is %p, should be NULL\n", tid1);
|
|
||||||
tc_stat(TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
{
|
|
||||||
rt_kprintf("tid2 is %p, should be NULL\n", tid2);
|
|
||||||
tc_stat(TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_delete()
|
|
||||||
{
|
|
||||||
/* set tc cleanup */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
return thread_delete_init();
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_delete, a thread delete example);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_delete_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,127 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：线程脱离
|
|
||||||
*
|
|
||||||
* 这个例子会创建两个线程，在其中一个线程中执行对另一个线程的脱离。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 线程1控制块 */
|
|
||||||
static struct rt_thread thread1;
|
|
||||||
/* 线程1栈 */
|
|
||||||
static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];
|
|
||||||
/* 线程2控制块 */
|
|
||||||
static struct rt_thread thread2;
|
|
||||||
/* 线程2栈 */
|
|
||||||
static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
|
|
||||||
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 线程1采用低优先级运行，一直打印计数值 */
|
|
||||||
rt_kprintf("thread count: %d\n", count ++);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
|
|
||||||
|
|
||||||
/* 线程2启动后先睡眠10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程2唤醒后直接执行线程1脱离，线程1将从就绪线程队列中删除
|
|
||||||
*/
|
|
||||||
rt_thread_detach(&thread1);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程2继续休眠10个OS Tick然后退出
|
|
||||||
*/
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 线程2运行结束后也将自动被从就绪队列中删除，并脱离线程队列
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_detach_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* 初始化线程1 */
|
|
||||||
result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */
|
|
||||||
thread1_entry, RT_NULL, /* 线程的入口是thread1_entry，入口参数是RT_NULL*/
|
|
||||||
&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
if (result == RT_EOK) /* 如果返回正确，启动线程1 */
|
|
||||||
rt_thread_startup(&thread1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 初始化线程2 */
|
|
||||||
result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */
|
|
||||||
thread2_entry, RT_NULL, /* 线程的入口是thread2_entry，入口参数是RT_NULL*/
|
|
||||||
&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */
|
|
||||||
THREAD_PRIORITY - 1, 10);
|
|
||||||
if (result == RT_EOK) /* 如果返回正确，启动线程2 */
|
|
||||||
rt_thread_startup(&thread2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 执行线程脱离 */
|
|
||||||
if (thread1.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread1);
|
|
||||||
if (thread2.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_detach()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_detach_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 25;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_detach, a static thread example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_detach_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,53 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread dynamicly created ok\n");
|
|
||||||
rt_thread_delay(10);
|
|
||||||
rt_kprintf("thread exit\n");
|
|
||||||
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_dynamic_init()
|
|
||||||
{
|
|
||||||
rt_thread_t tid;
|
|
||||||
|
|
||||||
tid = rt_thread_create("test",
|
|
||||||
thread_entry, RT_NULL,
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
rt_thread_startup(tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
int _tc_thread_dynamic()
|
|
||||||
{
|
|
||||||
thread_dynamic_init();
|
|
||||||
|
|
||||||
return 20;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_dynamic, a dynamic thread test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_dynamic_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,98 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：动态线程
|
|
||||||
*
|
|
||||||
* 这个程序会初始化2个动态线程，它们拥有共同的入口函数，但参数不相同
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
/* 线程入口 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 打印线程计数值输出 */
|
|
||||||
rt_kprintf("thread%d count: %d\n", no, count ++);
|
|
||||||
|
|
||||||
/* 休眠10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_dynamic_simple_init()
|
|
||||||
{
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("t1",
|
|
||||||
thread_entry, (void*)1, /* 线程入口是thread_entry, 入口参数是1 */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("t2",
|
|
||||||
thread_entry, (void*)2, /* 线程入口是thread_entry, 入口参数是2 */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_dynamic_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_dynamic_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_dynamic_simple, a dynamic thread example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_dynamic_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,114 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
struct rt_thread thread1;
|
|
||||||
struct rt_thread thread2;
|
|
||||||
static char thread1_stack[THREAD_STACK_SIZE];
|
|
||||||
static char thread2_stack[THREAD_STACK_SIZE];
|
|
||||||
static rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* the priority of thread1 > the priority of thread2
|
|
||||||
*/
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
count ++;
|
|
||||||
rt_kprintf("count = %d\n", count);
|
|
||||||
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t tick;
|
|
||||||
|
|
||||||
tick = rt_tick_get();
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
if (rt_tick_get() - tick >= 50)
|
|
||||||
{
|
|
||||||
if (count == 0)
|
|
||||||
tc_done(TC_STAT_FAILED);
|
|
||||||
else
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_priority_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
result = rt_thread_init(&thread1,
|
|
||||||
"t1",
|
|
||||||
thread1_entry, RT_NULL,
|
|
||||||
&thread1_stack[0], sizeof(thread1_stack),
|
|
||||||
THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_FAILED);
|
|
||||||
|
|
||||||
rt_thread_init(&thread2,
|
|
||||||
"t2",
|
|
||||||
thread2_entry, RT_NULL,
|
|
||||||
&thread2_stack[0], sizeof(thread2_stack),
|
|
||||||
THREAD_PRIORITY + 1, THREAD_TIMESLICE);
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
if (thread1.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread1);
|
|
||||||
if (thread2.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread2);
|
|
||||||
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
}
|
|
||||||
int _tc_thread_priority()
|
|
||||||
{
|
|
||||||
count = 0;
|
|
||||||
|
|
||||||
/* set tc cleanup */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_priority_init();
|
|
||||||
|
|
||||||
return RT_TICK_PER_SECOND;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_priority, a priority thread test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_priority_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,132 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：唤醒线程
|
|
||||||
*
|
|
||||||
* 这个例子中将创建两个动态线程，低优先级线程将挂起自身，然后
|
|
||||||
* 高优先级线程将在一定时刻后唤醒低优先级线程。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 低优先级线程1开始运行 */
|
|
||||||
rt_kprintf("thread1 startup%d\n");
|
|
||||||
|
|
||||||
/* 挂起自身 */
|
|
||||||
rt_kprintf("suspend thread self\n");
|
|
||||||
rt_thread_suspend(tid1);
|
|
||||||
/* 主动执行线程调度 */
|
|
||||||
rt_schedule();
|
|
||||||
|
|
||||||
/* 当线程1被唤醒时 */
|
|
||||||
rt_kprintf("thread1 resumed\n");
|
|
||||||
}
|
|
||||||
static void thread_cleanup(rt_thread_t tid)
|
|
||||||
{
|
|
||||||
if (tid == tid1)
|
|
||||||
{
|
|
||||||
tid1 = RT_NULL;
|
|
||||||
}
|
|
||||||
if (tid == tid2)
|
|
||||||
{
|
|
||||||
tid = RT_NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* 唤醒线程1 */
|
|
||||||
rt_thread_resume(tid1);
|
|
||||||
rt_kprintf("thread2: to resume thread1\n");
|
|
||||||
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* 线程2自动退出 */
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_resume_init()
|
|
||||||
{
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("thread",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
{
|
|
||||||
tid1->cleanup = thread_cleanup;
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("thread",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
{
|
|
||||||
tid2->cleanup = thread_cleanup;
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_resume()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_resume_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 25;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_resume, a thread resume example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_resume_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,105 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
static struct rt_thread thread1;
|
|
||||||
static struct rt_thread thread2;
|
|
||||||
static char thread1_stack[THREAD_STACK_SIZE];
|
|
||||||
static char thread2_stack[THREAD_STACK_SIZE];
|
|
||||||
|
|
||||||
volatile static rt_uint32_t t1_count = 0;
|
|
||||||
volatile static rt_uint32_t t2_count = 0;
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
t1_count ++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
t2_count ++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_err_t thread_same_priority_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
result = rt_thread_init(&thread1,
|
|
||||||
"t1",
|
|
||||||
thread1_entry, RT_NULL,
|
|
||||||
&thread1_stack[0], sizeof(thread1_stack),
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
result = rt_thread_init(&thread2,
|
|
||||||
"t2",
|
|
||||||
thread2_entry, RT_NULL,
|
|
||||||
&thread2_stack[0], sizeof(thread2_stack),
|
|
||||||
THREAD_PRIORITY, 5);
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* lock scheduler */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
if (thread1.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread1);
|
|
||||||
if (thread2.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread2);
|
|
||||||
|
|
||||||
/* unlock scheduler */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
rt_kprintf("t1_count=%d t2_count=%d\n",t1_count,t2_count);
|
|
||||||
|
|
||||||
if (t1_count / t2_count != 2)
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
else
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_same_priority()
|
|
||||||
{
|
|
||||||
t1_count = 0;
|
|
||||||
t2_count = 0;
|
|
||||||
|
|
||||||
/* set tc cleanup */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
|
|
||||||
thread_same_priority_init();
|
|
||||||
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_same_priority, a same priority thread test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_same_priority_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,61 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is an example for static thread
|
|
||||||
*/
|
|
||||||
static struct rt_thread thread;
|
|
||||||
static char thread_stack[THREAD_STACK_SIZE];
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("thread staticly inited ok\n");
|
|
||||||
rt_thread_delay(10);
|
|
||||||
rt_kprintf("thread exit\n");
|
|
||||||
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
rt_err_t thread_static_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
result = rt_thread_init(&thread,
|
|
||||||
"test",
|
|
||||||
thread_entry, RT_NULL,
|
|
||||||
&thread_stack[0], sizeof(thread_stack),
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
|
|
||||||
if (result == RT_EOK)
|
|
||||||
rt_thread_startup(&thread);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
int _tc_thread_static()
|
|
||||||
{
|
|
||||||
thread_static_init();
|
|
||||||
|
|
||||||
return 20;
|
|
||||||
}
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_static, a static thread test);
|
|
||||||
#else
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_static_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
@ -1,108 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：静态线程
|
|
||||||
*
|
|
||||||
* 这个程序会初始化2个静态线程，它们拥有共同的入口函数，但参数不相同
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 线程1控制块 */
|
|
||||||
static struct rt_thread thread1;
|
|
||||||
/* 线程1栈 */
|
|
||||||
static rt_uint8_t thread1_stack[THREAD_STACK_SIZE];
|
|
||||||
/* 线程2控制块 */
|
|
||||||
static struct rt_thread thread2;
|
|
||||||
/* 线程2栈 */
|
|
||||||
static rt_uint8_t thread2_stack[THREAD_STACK_SIZE];
|
|
||||||
|
|
||||||
/* 线程入口 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
rt_uint32_t no = (rt_uint32_t) parameter; /* 获得正确的入口参数 */
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 打印线程计数值输出 */
|
|
||||||
rt_kprintf("thread%d count: %d\n", no, count ++);
|
|
||||||
|
|
||||||
/* 休眠10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_static_simple_init()
|
|
||||||
{
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* 初始化线程1 */
|
|
||||||
result = rt_thread_init(&thread1, "t1", /* 线程名：t1 */
|
|
||||||
thread_entry, (void*)1, /* 线程的入口是thread_entry，入口参数是1 */
|
|
||||||
&thread1_stack[0], sizeof(thread1_stack), /* 线程栈是thread1_stack */
|
|
||||||
THREAD_PRIORITY, 10);
|
|
||||||
if (result == RT_EOK) /* 如果返回正确，启动线程1 */
|
|
||||||
rt_thread_startup(&thread1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 初始化线程2 */
|
|
||||||
result = rt_thread_init(&thread2, "t2", /* 线程名：t2 */
|
|
||||||
thread_entry, RT_NULL, /* 线程的入口是thread_entry，入口参数是2 */
|
|
||||||
&thread2_stack[0], sizeof(thread2_stack), /* 线程栈是thread2_stack */
|
|
||||||
THREAD_PRIORITY + 1, 10);
|
|
||||||
if (result == RT_EOK) /* 如果返回正确，启动线程2 */
|
|
||||||
rt_thread_startup(&thread2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 执行线程脱离 */
|
|
||||||
if (thread1.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread1);
|
|
||||||
if (thread2.stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_detach(&thread2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_static_simple()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_static_simple_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_static_simple, a static thread example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_static_simple_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,110 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：挂起线程
|
|
||||||
*
|
|
||||||
* 这个例子中将创建两个动态线程，高优先级线程将在一定时刻后挂起低优先级线程。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 线程1采用低优先级运行，一直打印计数值 */
|
|
||||||
rt_kprintf("thread count: %d\n", count ++);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* 挂起线程1 */
|
|
||||||
rt_thread_suspend(tid1);
|
|
||||||
|
|
||||||
/* 延时10个OS Tick */
|
|
||||||
rt_thread_delay(10);
|
|
||||||
|
|
||||||
/* 线程2自动退出 */
|
|
||||||
tid2 = RT_NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_suspend_init()
|
|
||||||
{
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("thread",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("thread",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_suspend()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_suspend_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_suspend, a thread suspend example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_suspend_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,107 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid1 = RT_NULL;
|
|
||||||
static rt_thread_t tid2 = RT_NULL;
|
|
||||||
/* 线程1入口 */
|
|
||||||
static void thread1_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 打印线程1的输出 */
|
|
||||||
rt_kprintf("thread1: count = %d\n", count ++);
|
|
||||||
|
|
||||||
/* 执行yield后应该切换到thread2执行 */
|
|
||||||
rt_thread_yield();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程2入口 */
|
|
||||||
static void thread2_entry(void* parameter)
|
|
||||||
{
|
|
||||||
rt_uint32_t count = 0;
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
/* 打印线程2的输出 */
|
|
||||||
rt_kprintf("thread2: count = %d\n", count ++);
|
|
||||||
|
|
||||||
/* 执行yield后应该切换到thread1执行 */
|
|
||||||
rt_thread_yield();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int thread_yield_init()
|
|
||||||
{
|
|
||||||
/* 创建线程1 */
|
|
||||||
tid1 = rt_thread_create("thread",
|
|
||||||
thread1_entry, RT_NULL, /* 线程入口是thread1_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid1 != RT_NULL)
|
|
||||||
rt_thread_startup(tid1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建线程2 */
|
|
||||||
tid2 = rt_thread_create("thread",
|
|
||||||
thread2_entry, RT_NULL, /* 线程入口是thread2_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid2 != RT_NULL)
|
|
||||||
rt_thread_startup(tid2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid1 != RT_NULL && tid1->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid1);
|
|
||||||
if (tid2 != RT_NULL && tid2->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_thread_yield()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
thread_yield_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 30;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_thread_yield, a thread yield example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
thread_yield_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,93 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：动态定时器例程
|
|
||||||
*
|
|
||||||
* 这个例程会创建1个动态周期型定时器对象，然后控制它进行定时时间长度的更改。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 定时器的控制块 */
|
|
||||||
static rt_timer_t timer1;
|
|
||||||
static rt_uint8_t count;
|
|
||||||
|
|
||||||
/* 定时器超时函数 */
|
|
||||||
static void timeout1(void* parameter)
|
|
||||||
{
|
|
||||||
rt_tick_t timeout = 50;
|
|
||||||
|
|
||||||
rt_kprintf("periodic timer is timeout\n");
|
|
||||||
|
|
||||||
count ++;
|
|
||||||
/* 停止定时器自身 */
|
|
||||||
if (count >= 8)
|
|
||||||
{
|
|
||||||
/* 控制定时器然后更改超时时间长度 */
|
|
||||||
rt_timer_control(timer1, RT_TIMER_CTRL_SET_TIME, (void *)&timeout);
|
|
||||||
count = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void timer_control_init()
|
|
||||||
{
|
|
||||||
/* 创建定时器1 */
|
|
||||||
timer1 = rt_timer_create("timer1", /* 定时器名字是 timer1 */
|
|
||||||
timeout1, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
|
|
||||||
RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
|
|
||||||
/* 启动定时器 */
|
|
||||||
if (timer1 != RT_NULL)
|
|
||||||
rt_timer_start(timer1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除定时器对象 */
|
|
||||||
rt_timer_delete(timer1);
|
|
||||||
timer1 = RT_NULL;
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_timer_control()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
|
|
||||||
/* 执行定时器例程 */
|
|
||||||
count = 0;
|
|
||||||
timer_control_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_timer_control, a timer control example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
timer_control_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,100 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：动态定时器例程
|
|
||||||
*
|
|
||||||
* 这个例程会创建两个动态定时器对象，一个是单次定时，一个是周期性的定时
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 定时器的控制块 */
|
|
||||||
static rt_timer_t timer1;
|
|
||||||
static rt_timer_t timer2;
|
|
||||||
|
|
||||||
/* 定时器1超时函数 */
|
|
||||||
static void timeout1(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("periodic timer is timeout\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 定时器2超时函数 */
|
|
||||||
static void timeout2(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("one shot timer is timeout\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
void timer_create_init()
|
|
||||||
{
|
|
||||||
/* 创建定时器1 */
|
|
||||||
timer1 = rt_timer_create("timer1", /* 定时器名字是 timer1 */
|
|
||||||
timeout1, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
|
|
||||||
RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
|
|
||||||
/* 启动定时器 */
|
|
||||||
if (timer1 != RT_NULL)
|
|
||||||
rt_timer_start(timer1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
/* 创建定时器2 */
|
|
||||||
timer2 = rt_timer_create("timer2", /* 定时器名字是 timer2 */
|
|
||||||
timeout2, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
30, /* 定时长度为30个OS Tick */
|
|
||||||
RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
|
|
||||||
|
|
||||||
/* 启动定时器 */
|
|
||||||
if (timer2 != RT_NULL)
|
|
||||||
rt_timer_start(timer2);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除定时器对象 */
|
|
||||||
rt_timer_delete(timer1);
|
|
||||||
rt_timer_delete(timer2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_timer_create()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
|
|
||||||
/* 执行定时器例程 */
|
|
||||||
timer_create_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_timer_create, a dynamic timer example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
timer_create_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,91 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：定时器例程
|
|
||||||
*
|
|
||||||
* 这个程序会初始化2个静态定时器，一个是单次定时，一个是周期性的定时
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 定时器的控制块 */
|
|
||||||
static struct rt_timer timer1;
|
|
||||||
static struct rt_timer timer2;
|
|
||||||
|
|
||||||
/* 定时器1超时函数 */
|
|
||||||
static void timeout1(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("periodic timer is timeout\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 定时器2超时函数 */
|
|
||||||
static void timeout2(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("one shot timer is timeout\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
void timer_static_init()
|
|
||||||
{
|
|
||||||
/* 初始化定时器 */
|
|
||||||
rt_timer_init(&timer1, "timer1", /* 定时器名字是 timer1 */
|
|
||||||
timeout1, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
|
|
||||||
RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
|
|
||||||
rt_timer_init(&timer2, "timer2", /* 定时器名字是 timer2 */
|
|
||||||
timeout2, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
30, /* 定时长度为30个OS Tick */
|
|
||||||
RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */
|
|
||||||
|
|
||||||
/* 启动定时器 */
|
|
||||||
rt_timer_start(&timer1);
|
|
||||||
rt_timer_start(&timer2);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 执行定时器脱离 */
|
|
||||||
rt_timer_detach(&timer1);
|
|
||||||
rt_timer_detach(&timer2);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_timer_static()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
|
|
||||||
/* 执行定时器例程 */
|
|
||||||
timer_static_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_timer_static, a static timer example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
timer_static_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,91 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：动态定时器例程
|
|
||||||
*
|
|
||||||
* 这个例程会创建1个动态周期型定时器对象
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 定时器的控制块 */
|
|
||||||
static rt_timer_t timer1;
|
|
||||||
static rt_uint8_t count;
|
|
||||||
|
|
||||||
/* 定时器超时函数 */
|
|
||||||
static void timeout1(void* parameter)
|
|
||||||
{
|
|
||||||
rt_kprintf("periodic timer is timeout\n");
|
|
||||||
|
|
||||||
count ++;
|
|
||||||
/* 停止定时器自身 */
|
|
||||||
if (count >= 8)
|
|
||||||
{
|
|
||||||
/* 停止定时器 */
|
|
||||||
rt_timer_stop(timer1);
|
|
||||||
count = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void timer_stop_self_init()
|
|
||||||
{
|
|
||||||
/* 创建定时器1 */
|
|
||||||
timer1 = rt_timer_create("timer1", /* 定时器名字是 timer1 */
|
|
||||||
timeout1, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
10, /* 定时长度，以OS Tick为单位，即10个OS Tick */
|
|
||||||
RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
|
|
||||||
/* 启动定时器 */
|
|
||||||
if (timer1 != RT_NULL)
|
|
||||||
rt_timer_start(timer1);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除定时器对象 */
|
|
||||||
rt_timer_delete(timer1);
|
|
||||||
timer1 = RT_NULL;
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_timer_stop_self()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
|
|
||||||
/* 执行定时器例程 */
|
|
||||||
count = 0;
|
|
||||||
timer_stop_self_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_timer_stop_self, a dynamic timer example);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
timer_stop_self_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,131 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
||||||
*
|
|
||||||
* SPDX-License-Identifier: Apache-2.0
|
|
||||||
*
|
|
||||||
* Change Logs:
|
|
||||||
*
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* 程序清单：消息队列例程
|
|
||||||
*
|
|
||||||
* 这个程序会创建3个动态线程，一个线程会从消息队列中收取消息；一个线程会定时给消
|
|
||||||
* 息队列发送消息；一个线程会定时给消息队列发送紧急消息。
|
|
||||||
*/
|
|
||||||
#include <rtthread.h>
|
|
||||||
#include "tc_comm.h"
|
|
||||||
|
|
||||||
/* 指向线程控制块的指针 */
|
|
||||||
static rt_thread_t tid = RT_NULL;
|
|
||||||
|
|
||||||
/* 消息队列控制块 */
|
|
||||||
static struct rt_messagequeue mq;
|
|
||||||
/* 消息队列中用到的放置消息的内存池 */
|
|
||||||
static char msg_pool[2048];
|
|
||||||
|
|
||||||
/* 定时器的控制块 */
|
|
||||||
static struct rt_timer timer;
|
|
||||||
static rt_uint16_t no = 0;
|
|
||||||
static void timer_timeout(void* parameter)
|
|
||||||
{
|
|
||||||
char buf[32];
|
|
||||||
rt_uint32_t length;
|
|
||||||
|
|
||||||
length = rt_snprintf(buf, sizeof(buf), "message %d", no++);
|
|
||||||
rt_mq_send(&mq, &buf[0], length);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 线程入口函数 */
|
|
||||||
static void thread_entry(void* parameter)
|
|
||||||
{
|
|
||||||
char buf[64];
|
|
||||||
rt_err_t result;
|
|
||||||
|
|
||||||
/* 初始化定时器 */
|
|
||||||
rt_timer_init(&timer, "timer", /* 定时器名字是 timer1 */
|
|
||||||
timer_timeout, /* 超时时回调的处理函数 */
|
|
||||||
RT_NULL, /* 超时函数的入口参数 */
|
|
||||||
1, /* 定时长度，以OS Tick为单位，即1个OS Tick */
|
|
||||||
RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
|
|
||||||
|
|
||||||
while (1)
|
|
||||||
{
|
|
||||||
rt_memset(&buf[0], 0, sizeof(buf));
|
|
||||||
|
|
||||||
/* 从消息队列中接收消息 */
|
|
||||||
result = rt_mq_recv(&mq, &buf[0], sizeof(buf), 1);
|
|
||||||
if (result == RT_EOK)
|
|
||||||
{
|
|
||||||
rt_kprintf("recv msg: %s\n", buf);
|
|
||||||
}
|
|
||||||
else if (result == -RT_ETIMEOUT)
|
|
||||||
{
|
|
||||||
rt_kprintf("recv msg timeout\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int timer_timeout_init()
|
|
||||||
{
|
|
||||||
/* 初始化消息队列 */
|
|
||||||
rt_mq_init(&mq, "mqt",
|
|
||||||
&msg_pool[0], /* 内存池指向msg_pool */
|
|
||||||
128 - sizeof(void*), /* 每个消息的大小是 128 - void* */
|
|
||||||
sizeof(msg_pool), /* 内存池的大小是msg_pool的大小 */
|
|
||||||
RT_IPC_FLAG_PRIO); /* 如果有多个线程等待，按照优先级由高到低的方法分配消息 */
|
|
||||||
|
|
||||||
/* 创建线程 */
|
|
||||||
tid = rt_thread_create("t",
|
|
||||||
thread_entry, RT_NULL, /* 线程入口是thread_entry, 入口参数是RT_NULL */
|
|
||||||
THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
||||||
if (tid != RT_NULL)
|
|
||||||
rt_thread_startup(tid);
|
|
||||||
else
|
|
||||||
tc_stat(TC_STAT_END | TC_STAT_FAILED);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef RT_USING_TC
|
|
||||||
static void _tc_cleanup()
|
|
||||||
{
|
|
||||||
/* 调度器上锁，上锁后，将不再切换到其他线程，仅响应中断 */
|
|
||||||
rt_enter_critical();
|
|
||||||
|
|
||||||
/* 删除线程 */
|
|
||||||
if (tid != RT_NULL && tid->stat != RT_THREAD_CLOSE)
|
|
||||||
rt_thread_delete(tid);
|
|
||||||
|
|
||||||
/* 执行消息队列对象脱离 */
|
|
||||||
rt_mq_detach(&mq);
|
|
||||||
/* 执行定时器脱离 */
|
|
||||||
rt_timer_detach(&timer);
|
|
||||||
|
|
||||||
/* 调度器解锁 */
|
|
||||||
rt_exit_critical();
|
|
||||||
|
|
||||||
/* 设置TestCase状态 */
|
|
||||||
tc_done(TC_STAT_PASSED);
|
|
||||||
}
|
|
||||||
|
|
||||||
int _tc_timer_timeout()
|
|
||||||
{
|
|
||||||
/* 设置TestCase清理回调函数 */
|
|
||||||
tc_cleanup(_tc_cleanup);
|
|
||||||
timer_timeout_init();
|
|
||||||
|
|
||||||
/* 返回TestCase运行的最长时间 */
|
|
||||||
return 100;
|
|
||||||
}
|
|
||||||
/* 输出函数命令到finsh shell中 */
|
|
||||||
FINSH_FUNCTION_EXPORT(_tc_timer_timeout, a thread timer testcase);
|
|
||||||
#else
|
|
||||||
/* 用户应用入口 */
|
|
||||||
int rt_application_init()
|
|
||||||
{
|
|
||||||
timer_timeout_init();
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
Loading…
Reference in New Issue