从零手写操作系统之RVOS软件定时器实现-08

/* software timer */
struct timer {
	//定时器超时后,任务执行器函数的入口地址
	void (*func)(void *arg);
	//参数
	void *arg;
	//超时计数器
	uint32_t timeout_tick;
};
//创建一个软件定时器任务 --- 任务执行器函数入口地址,函数实参,超时时间
extern struct timer *timer_create(void (*handler)(void *arg), void *arg, uint32_t timeout);
//删除一个软件定时器任务
extern void timer_delete(struct timer *timer);

//最多支持同时存在10个软件定时器
#define MAX_TIMER 10
//采用数组存放软件定时器列表
static struct timer timer_list[MAX_TIMER];

//在原有的硬件定时器初始化逻辑之上,增加对软件定时器模块初始化支持
void timer_init()
{
    //初始化所有软件定时器任务
	struct timer *t = &(timer_list[0]);
	for (int i = 0; i < MAX_TIMER; i++) {
	    //将每个任务的func和arg清空
		t->func = NULL; /* use .func to flag if the item is used */
		t->arg = NULL;
		t++;
	}
    
    //--------------------下面是硬件定时器模块的初始化逻辑---------------------------------

	/*
	 * On reset, mtime is cleared to zero, but the mtimecmp registers 
	 * are not reset. So we have to init the mtimecmp manually.
	 */
	//硬件定时器模块初始化---传入interval间隔大约为1s
	timer_load(TIMER_INTERVAL);

	/* enable machine-mode timer interrupts. */
	//设置mie寄存器的MTIE位为1,开启时钟中断
	w_mie(r_mie() | MIE_MTIE);
}

/* load timer interval(in ticks) for next timer interrupt.*/
void timer_load(int interval)
{
	/* each CPU has a separate source of timer interrupts. */
	//获取当前hartId
	int id = r_mhartid();
	//设置mtimecmp寄存器的值为mtime寄存器的值+interval
	*(uint64_t*)CLINT_MTIMECMP(id) = *(uint64_t*)CLINT_MTIME + interval;
}

//创建软件定时器任务
struct timer *timer_create(void (*handler)(void *arg), void *arg, uint32_t timeout)
{
	/* TBD: params should be checked more, but now we just simplify this */
	if (NULL == handler || 0 == timeout) {
		return NULL;
	}

	/* use lock to protect the shared timer_list between multiple tasks */
	//使用锁来保护对共享软件定时器任务列表的操作---此处采用关中断实现
	spin_lock();
    //从软件定时器数组中寻找到第一个空位
	struct timer *t = &(timer_list[0]);
	for (int i = 0; i < MAX_TIMER; i++) {
		if (NULL == t->func) {
			break;
		}
		t++;
	}
	//如果没有剩余空位,那么返回NULL,表示软件定时器数组满了,创建失败
	if (NULL != t->func) {
		spin_unlock();
		return NULL;
	}
    //初始化软件定时任务
	t->func = handler;
	t->arg = arg;
	//_tick变量,记录系统从启动开始到现在为止,产生的时钟中断次数
	//_tick + timeout表示,从现在开始的第timeout次时钟中断后,软件定时器任务到期
	//由于本课程中默认设置时钟中断间隔为1s,所以等同于说: 软件定时器任务timeout秒后被调用执行
	t->timeout_tick = _tick + timeout;
    //释放锁
	spin_unlock();
	return t;
}

//--------------------下面是硬件定时器小节添加的逻辑---------------------------------

//用于记录
static uint32_t _tick = 0;

//发生定时器中断时,会调用该处理函数
void timer_handler() {
    //不断累加,记录系统从启动开始到现在为止,产生的时钟中断次数
	_tick++;
	printf("tick: %d\n", _tick);
	//本节在定时器中断处理函数中新增对软件定时器任务到期检查
	timer_check();
	//重置下一次时钟中断发生时间 -- 1s发生一次
	timer_load(TIMER_INTERVAL);
	//进行任务调度
	schedule();
}

void timer_delete(struct timer *timer)
{
    //使用锁来保护对共享软件定时器任务列表的操作---此处采用关中断实现
	spin_lock();
	struct timer *t = &(timer_list[0]);
	for (int i = 0; i < MAX_TIMER; i++) {
	    //定位到目标软件定时器,然后清空func和arg即可
		if (t == timer) {
			t->func = NULL;
			t->arg = NULL;
			break;
		}
		t++;
	}
    //释放锁
	spin_unlock();
}

/* this routine should be called in interrupt context (interrupt is disabled) */
static inline void timer_check()
{
	struct timer *t = &(timer_list[0]);
	for (int i = 0; i < MAX_TIMER; i++) {
		if (NULL != t->func) {
		    //判断是否有软件定时器任务到期
			if (_tick >= t->timeout_tick) {
				//发现一个到期的软件定时器任务,触发任务执行
				t->func(t->arg);

				/* once time, just delete it after timeout */
				//只会触发一次,触发后,就删除当前定时器任务
				t->func = NULL;
				t->arg = NULL;
                //跳出循环,一次时钟中断,最多执行一个到期的定时器任务
				break;
			}
		}
		t++;
	}
}

/* software timer */
struct timer {
	void (*func)(void *arg);
	void *arg;
	//是否为周期性任务
	uint32_t period;
	//周期性触发间隔
	uint32_t period_time;
	//下一次触发时机
	uint32_t timeout_tick;
};

/* this routine should be called in interrupt context (interrupt is disabled) */
static inline void timer_check()
{
	struct timer *t = &(timer_list[0]);
	for (int i = 0; i < MAX_TIMER; i++) {
		if (NULL != t->func) {
			if (_tick >= t->timeout_tick) {
				t->func(t->arg);
                //非周期性任务,执行完直接删除
				if(t->period<=0){
                    /* once time, just delete it after timeout */
				    t->func = NULL;
				    t->arg = NULL;
					t->period=0;
					t->period_time=0;
				}else{
					//更新周期性任务下一次触发的时间
					t->timeout_tick=_tick+t->period_time;
				}
				break;
			}
		}
		t++;
	}
}

#include "os.h"
#define DELAY 4000

void timer_func(void *arg)
{
	if (NULL == arg)
		return;
	printf("%s\n",arg);
}

void user_task0(void)
{
	uart_puts("Task 0: Created!\n");
    //创建一个周期性任务
	struct timer *t1 = timer_create(timer_func,"task 1", 3,1);
	if (NULL == t1) {
		printf("timer_create() failed!\n");
	}
	//下面创建两个一次性定时任务
	struct timer *t2 = timer_create(timer_func, "task 2", 5,0);
	if (NULL == t2) {
		printf("timer_create() failed!\n");
	}
	struct timer *t3 = timer_create(timer_func, "task 3", 7,0);
	if (NULL == t3) {
		printf("timer_create() failed!\n");
	}
	while (1) {
		uart_puts("Task 0: Running... \n");
		task_delay(DELAY);
	}
}

void user_task1(void)
{
	uart_puts("Task 1: Created!\n");
	while (1) {
		uart_puts("Task 1: Running... \n");
		task_delay(DELAY);
	}
}

/* NOTICE: DON'T LOOP INFINITELY IN main() */
void os_main(void)
{
	task_create(user_task0);
	task_create(user_task1);
}