在分析硬件定时器框架时，我们发现硬件定时器基于的是mcu提供的systick定时器, 会存在影响系统调度速度以及精度的问题。而为了解决这个问题，rtt引入了cputime的模块，cputime 通过对接单独的硬件定时器来实现，提高了精度，不过作为代价是，在每个 bsp 中都需要具体实现 cputime 的对接工作。
cputime模块解析
源码路径
RTT_PATH\components\drivers\cputime\ cputime.c // cputime框架代码 cputimer.c // cputime对应用暴露的接口 cputime_cortexm.c //cortex m核的cputime实现代码 cputime_riscv.c // riscv核的cputime实现代码
由于源码中存在两个核的对接实现，因此暂时只看cortexm核部分。
对接驱动接口
cputime注册接口
struct rt_clock_cputime_ops
{
// 获取剩余时间入口
uint64_t (*cputime_getres)(void);
// 获取当前时间入口
uint64_t (*cputime_gettime)(void);
// 设置硬件定时器超时时间，回调函数，以及回调函数的参数的入口
int (*cputime_settimeout)(uint64_t tick, void (*timeout)(void *param), void *param);
};
int clock_cpu_setops(const struct rt_clock_cputime_ops *ops)
{
_cputime_ops = ops;
if (ops)
{
RT_ASSERT(ops->cputime_getres != RT_NULL);
RT_ASSERT(ops->cputime_gettime != RT_NULL);
}
return 0;
}
// 很奇怪，cortexm核的处理和riscv核的处理，都没有注册cputime_settimeout
// 只能说，可能两份源码都不是最终的实现，但即使是参考的，也应该把这个实现写出来吧
const static struct rt_clock_cputime_ops _cortexm_ops =
{
cortexm_cputime_getres,
cortexm_cputime_gettime
};
int cortexm_cputime_init(void) // cortexm核的注册函数
{
#ifdef PKG_USING_PERF_COUNTER
clock_cpu_setops(&_cortexm_ops);
#else
/* check support bit */
if ((DWT->CTRL & (1UL << DWT_CTRL_NOCYCCNT_Pos)) == 0)
{
/* enable trace*/
CoreDebug->DEMCR |= (1UL << CoreDebug_DEMCR_TRCENA_Pos);
/* whether cycle counter not enabled */
if ((DWT->CTRL & (1UL << DWT_CTRL_CYCCNTENA_Pos)) == 0)
{
/* enable cycle counter */
DWT->CTRL |= (1UL << DWT_CTRL_CYCCNTENA_Pos);
}
clock_cpu_setops(&_cortexm_ops);
}
#endif /* PKG_USING_PERF_COUNTER */
return 0;
}
INIT_BOARD_EXPORT(cortexm_cputime_init);对接应用接口
注册函数
void rt_cputimer_init(rt_cputimer_t timer,
const char *name,
void (*timeout)(void *parameter),
void *parameter,
rt_uint64_t tick,
rt_uint8_t flag)
{
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(timeout != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
/* set flag */
timer->parent.flag = flag;
/* set deactivated */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer->timeout_func = timeout;
timer->parameter = parameter;
timer->timeout_tick = tick + clock_cpu_gettime();
timer->init_tick = tick;
rt_list_init(&(timer->row));
rt_sem_init(&(timer->sem), "cputime", 0, RT_IPC_FLAG_PRIO);
}与之前的几个定时器不一样的是，cputimer并没有提供create函数，仅提供了init，也就意味着变量struct rt_cputimer只能外部定义好，再调用init函数完成参数初始化。
cputime启动函数
int clock_cpu_settimeout(uint64_t tick, void (*timeout)(void *param), void *param)
{
if (_cputime_ops)
return _cputime_ops->cputime_settimeout(tick, timeout, param);
rt_set_errno(ENOSYS);
return 0;
}
static void _cputime_timeout_callback(void *parameter) // cputime超时回调函数
{
struct rt_cputimer *timer;
timer = (struct rt_cputimer *)parameter;
rt_base_t level;
level = rt_hw_interrupt_disable();
_cputimer_nowtimer = RT_NULL;
rt_list_remove(&(timer->row));
rt_hw_interrupt_enable(level);
timer->timeout_func(timer->parameter); //调用超时回调处理
if (&_cputimer_list != _cputimer_list.prev) // 定时器列表非空，直接启用下一个定时器
{
struct rt_cputimer *t;
t = rt_list_entry(_cputimer_list.next, struct rt_cputimer, row);
clock_cpu_settimeout(t->timeout_tick, _cputime_timeout_callback, t);
}
else
{
clock_cpu_settimeout(RT_NULL, RT_NULL, RT_NULL);
}
}
static void _set_next_timeout()
{
struct rt_cputimer *t;
if (&_cputimer_list != _cputimer_list.prev) // 如果链表非空，则启动定时器
{
t = rt_list_entry((&_cputimer_list)->next, struct rt_cputimer, row);
if (_cputimer_nowtimer != RT_NULL)
{ // 如果当前有定时器任务在执行，则需要判断新插入的定时器的超时时间是否比当前任务短
if (t != _cputimer_nowtimer && t->timeout_tick < _cputimer_nowtimer->timeout_tick)
{ // 若新定时器的超时时间比当前定时器的超时时间短，则更新定时器超时时间
_cputimer_nowtimer = t;
clock_cpu_settimeout(t->timeout_tick, _cputime_timeout_callback, t);
}
}
else
{ // 如果当前没有定时器任务在执行，则直接启用定时器
_cputimer_nowtimer = t;
clock_cpu_settimeout(t->timeout_tick, _cputime_timeout_callback, t);
}
}
else // 非空，则禁用定时器
{
_cputimer_nowtimer = RT_NULL;
clock_cpu_settimeout(RT_NULL, RT_NULL, RT_NULL);
}
}
rt_err_t rt_cputimer_start(rt_cputimer_t timer)
{
rt_list_t *timer_list;
rt_base_t level;
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
/* stop timer firstly */
level = rt_hw_interrupt_disable();
/* remove timer from list */
rt_list_remove(&timer->row); // 将当前定时器从启用的定时器列表中移除
/* change status of timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer_list = &_cputimer_list;
for (; timer_list != _cputimer_list.prev; // 按照时间从小到大的顺序，将当前定时器插入定时器列表
timer_list = timer_list->next)
{
struct rt_cputimer *t;
rt_list_t *p = timer_list->next;
t = rt_list_entry(p, struct rt_cputimer, row);
if ((t->timeout_tick - timer->timeout_tick) == 0)
{
continue;
}
else if ((t->timeout_tick - timer->timeout_tick) < 0x7fffffffffffffff)
{
break;
}
}
rt_list_insert_after(timer_list, &(timer->row));
timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;
_set_next_timeout(); // 设置下一次的定时器唤醒任务
/* enable interrupt */
rt_hw_interrupt_enable(level);
return RT_EOK;
}这里，个人认为可能存在一个问题，timerout的计时，在start函数中并没有被重新设置，也就意味着，如果上层init定时器参数后，但没有立马调用start函数，就会存在实际start时，定时器就已经超时的问题。
cputime配置函数
rt_err_t rt_cputimer_control(rt_cputimer_t timer, int cmd, void *arg)
{
rt_base_t level;
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
level = rt_hw_interrupt_disable();
switch (cmd)
{
case RT_TIMER_CTRL_GET_TIME: // 获取超时时间设置
*(rt_uint64_t *)arg = timer->init_tick;
break;
case RT_TIMER_CTRL_SET_TIME: // 设置超时时间
RT_ASSERT((*(rt_uint64_t *)arg) < 0x7fffffffffffffff);
timer->init_tick = *(rt_uint64_t *)arg;
timer->timeout_tick = *(rt_uint64_t *)arg + clock_cpu_gettime();
break;
case RT_TIMER_CTRL_SET_ONESHOT: //设置为单次触发模式
timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;
break;
case RT_TIMER_CTRL_SET_PERIODIC: // 设置为周期触发模式
timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;
break;
case RT_TIMER_CTRL_GET_STATE: // 获取当前运行状态
if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
{
/*timer is start and run*/
*(rt_uint32_t *)arg = RT_TIMER_FLAG_ACTIVATED;
}
else
{
/*timer is stop*/
*(rt_uint32_t *)arg = RT_TIMER_FLAG_DEACTIVATED;
}
break;
case RT_TIMER_CTRL_GET_REMAIN_TIME: // 获取当前设置的超时时间精确值
*(rt_uint64_t *)arg = timer->timeout_tick;
break;
case RT_TIMER_CTRL_GET_FUNC: // 获取超时回调函数
arg = (void *)timer->timeout_func;
break;
case RT_TIMER_CTRL_SET_FUNC: // 设置超时回调函数
timer->timeout_func = (void (*)(void *))arg;
break;
case RT_TIMER_CTRL_GET_PARM: // 获取定时器参数
*(void **)arg = timer->parameter;
break;
case RT_TIMER_CTRL_SET_PARM: // 设置定时器参数
timer->parameter = arg;
break;
default:
break;
}
rt_hw_interrupt_enable(level);
return RT_EOK;
}这部分的入口，和前面几个定时器提供的接口，也是一致的，并没有什么不同。但是有个问题，cputime的执行函数中，并没有看到周期执行的处理，这个control函数设置周期执行或单次执行，其实并没有功能。
cputime停止函数
rt_err_t rt_cputimer_stop(rt_cputimer_t timer)
{
rt_base_t level;
/* disable interrupt */
level = rt_hw_interrupt_disable();
/* timer check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))
{
rt_hw_interrupt_enable(level);
return -RT_ERROR;
}
rt_list_remove(&timer->row);
/* change status */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
_set_next_timeout();
/* enable interrupt */
rt_hw_interrupt_enable(level);
return RT_EOK;
}停止函数的实现就很直白了，如果是启用状态，则从启用列表中移除定时器，并将定时器的可执行状态切换为非执行中，同时更新定时器的超时处理信息。
cputime删除函数
rt_err_t rt_cputimer_delete(rt_cputimer_t timer)
{
rt_base_t level;
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
/* disable interrupt */
level = rt_hw_interrupt_disable();
rt_list_remove(&timer->row);
/* stop timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
/* enable interrupt */
rt_hw_interrupt_enable(level);
_set_next_timeout();
return RT_EOK;
}删除函数的实现，有些看不明白，如果当前cputime任务并不在定时器列表中，那删除还需要再去执行一遍更新定时器的超时信息？
cputime分离函数
rt_err_t rt_cputimer_detach(rt_cputimer_t timer)
{
rt_base_t level;
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(clock_cpu_issettimeout() != RT_FALSE);
/* disable interrupt */
level = rt_hw_interrupt_disable();
rt_list_remove(&timer->row);
/* stop timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
_set_next_timeout();
/* enable interrupt */
rt_hw_interrupt_enable(level);
rt_sem_detach(&(timer->sem));
return RT_EOK;
}同删除函数一样的问题，在没使用的时候也需要更新一次定时器超时处理信息，很奇怪。另外timer->sem这个信号量压根就没使用，为了一个没有使用的信号量写一个detach函数，很奇怪。
cputime休眠函数
static void _cputime_sleep_timeout(void *parameter)
{
struct rt_semaphore *sem;
sem = (struct rt_semaphore *)parameter;
rt_sem_release(sem); // 释放信号量
}
rt_err_t rt_cputime_sleep(rt_uint64_t tick)
{
rt_base_t level;
struct rt_cputimer cputimer;
if (!clock_cpu_issettimeout())
{
rt_int32_t ms = clock_cpu_millisecond(tick);
return rt_thread_delay(rt_tick_from_millisecond(ms));
}
if (tick == 0)
{
return -RT_EINVAL;
}
rt_cputimer_init(&cputimer, "cputime_sleep", _cputime_sleep_timeout, &(cputimer.sem), tick,
RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); //初始化cputime
/* disable interrupt */
level = rt_hw_interrupt_disable();
rt_cputimer_start(&cputimer); /* reset the timeout of thread timer and start it */
rt_hw_interrupt_enable(level);
rt_sem_take_interruptible(&(cputimer.sem), RT_WAITING_FOREVER); // 等待信号量释放
rt_cputimer_detach(&cputimer);
return RT_EOK;
}
// ns级别的延时
rt_err_t rt_cputime_ndelay(rt_uint64_t ns)
{
uint64_t unit = clock_cpu_getres();
return rt_cputime_sleep(ns * (1000UL * 1000) / unit);
}
// us级别的延时
rt_err_t rt_cputime_udelay(rt_uint64_t us)
{
return rt_cputime_ndelay(us * 1000);
}
// ms级别的延时
rt_err_t rt_cputime_mdelay(rt_uint64_t ms)
{
return rt_cputime_ndelay(ms * 1000000);
}从这里，我们可以发现，cputime延时本质上是利用信号量和cputime的精确定时功能，完成相对高精度的延时等待，可以实现rtthread_mdelay无法实现的us级别的延时设置。
总结
首先，目前看提供的驱动层参考实现并不完美（缺乏最关键的超时回调处理，且其他代码也不确定是否真实有效）。此外，目前并未发现哪块板卡专门适配了该模块，若需使用，则需自行适配。
其次，cputime仅仅实现了单次出发的模式，若想实现连续触发，并不能使用cputime模块。但不可否认的是，cputime能够实现与硬件定时器一致的高精度超时处理函数，并将处理效果等同于rt_thread_mdelay函数的实现。
最后，目前版本的cputime，在使用时一定得注意，要么直接init后start，要么RT_TIMER_CTRL_SET_TIME后start，否则存在超时时间与所需超时时间不一致的问题，或者若有兴趣修复这个bug的话，可以直接修改cputime的源码，做到与其他几个定时器框架的实现思路一致。
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂