eCos嘀嗒定时器

最新推荐文章于 2024-12-17 10:37:55 发布

半斗米

最新推荐文章于 2024-12-17 10:37:55 发布

阅读量4.6k

点赞数 3

分类专栏：实时操作系统文章标签： ecos tick

本文链接：https://blog.youkuaiyun.com/zoomdy/article/details/8869843

版权

实时操作系统专栏收录该内容

53 篇文章

订阅专栏

mingdu.zheng <at> gmail <dot> com
http://blog.youkuaiyun.com/zoomdy/article/details/8869843

1. 概述

嘀嗒定时器（Tick）是操作系统的核心部件之一，操作系统使用嘀嗒定时器实现时间片轮、延时、超时判断等特性。本文介绍eCos系统中的嘀嗒定时器的使用和实现，以及需要考虑的一些问题。

嘀嗒定时器在eCos中称做RealTimeClock（RTC），一般情况下，RTC是指提供年月日时分秒的实时时钟，在eCos中RTC表示嘀嗒定时器，WallClock（挂钟）才是指提供年月日时分秒的实时时钟，为什么是这样？

通常使用定时器模块为系统提供嘀嗒定时服务，Cortex-M提供了专用的SysTick定时器。

嘀嗒定时器与硬件相关的代码是由HAL提供的，与硬件无关的代码由内核的clock.cxx提供，ISR和DSR也是由clock.cxx提供的。

2. 配置项

共有3个配置项与嘀嗒定时器有关，分别是：Real-time clock numerator（CYGNUM_HAL_RTC_NUMERATOR）、 Real-time clock denominator（CYGNUM_HAL_RTC_DENOMINATOR）、Real-time clock period（CYGNUM_HAL_RTC_PERIOD），这3个配置项通常在平台层HAL或变体层HAL定义。

CYGNUM_HAL_RTC_NUMERATOR和CYGNUM_HAL_RTC_DENOMINATOR定义嘀嗒定时器中断间隔时间，中断间隔时间 =CYGNUM_HAL_RTC_NUMERATOR / CYGNUM_HAL_RTC_DENOMINATOR，单位为纳秒（ns）。默认情况下CYGNUM_HAL_RTC_NUMERATOR = 1000000000ns = 1s，CYGNUM_HAL_RTC_DENOMINATOR = 100，中断间隔 = 1000000000 / 100 = 10000000ns = 10ms。在CYGNUM_HAL_RTC_NUMERATOR = 1s 的情况下， CYGNUM_HAL_RTC_DENOMINATOR 等于每秒产生的嘀嗒数。据eCos参考手册的描述，采用分子分母的形式来定义中断间隔的原因是提高分辨率减少误差，在CYGNUM_HAL_RTC_NUMERATOR不能被CYGNUM_HAL_RTC_DENOMINATOR整除的情况下，确实是这么一回事。

CYGNUM_HAL_RTC_PERIOD是嘀嗒定时器中断间隔时间内CPU运行的时钟数，这个选项用来初始化定时器硬件，一般情况下，CYGNUM_HAL_RTC_PERIOD = CPU主频 / CYGNUM_HAL_RTC_DENOMINATOR。

3. 内核函数

与嘀嗒定时器相关的内核函数包括cyg_current_time、cyg_thread_delay以及支持超时机制的通信和同步函数。

cyg_tick_count_t cyg_current_time(void)：读取当前嘀嗒计数器值，返回值类型为cyg_tick_count_t，这是个64位无符号整数类型。

void cyg_thread_delay(cyg_tick_count_t delay)：线程延时，delay为需要延时的嘀嗒数。

支持超时机制的通信和同步函数包括cyg_mbox_timed_get、cyg_mbox_timed_put、cyg_semaphore_timed_wait、cyg_flag_timed_wait、cyg_cond_timed_wait，这些函数都有一个abstime参数，abstime是嘀嗒计数器值的绝对值，这是与cyg_thread_delay的delay参数不同的，在使用这些函数前首先要调用cyg_current_time获取当前计数器值，然后加上超时时间再传给abstime参数，为什么不使用和cyg_thread_delay一样的相对计数器值呢？下面是使用超时等待条件变量的一个简单例子。

res = cyg_cond_timed_wait( cv, cyg_current_time()+10 );

4. HAL代码

HAL为内核实现嘀嗒定时器提供3个硬件相关的宏定义：HAL_CLOCK_INITIALIZE、HAL_CLOCK_RESET、 CYGNUM_HAL_INTERRUPT_RTC

HAL_CLOCK_INITIALIZE( _period_ )对定时器进行初始化，通常对定时器模块相关的寄存器进行设置，但是不会安装ISR和DSR，也不会使能中断，这部分工作由内核在初始化嘀嗒定时器时完成。 _period_为CYGNUM_HAL_RTC_PERIOD。

HAL_CLOCK_RESET( _vec_, _period_ )清除定时器中断标志，复位计数器值，在ISR中调用， _vec_为CYGNUM_HAL_INTERRUPT_RTC，_period_为CYGNUM_HAL_RTC_PERIOD。

CYGNUM_HAL_INTERRUPT_RTC嘀嗒定时器的中断号，定时器中断的ISR和DSR是由内核提供的，只有知道中断号的情况下，才能安装ISR和DSR，以及屏蔽和使能中断。

5. 内核代码

与嘀嗒定时器相关的内核代码主要在kernel/.../src/common/clock.cxx中实现。嘀嗒定时器功能由C++类Cyg_RealTimeClock提供，clock.cxx定义了一个全局的Cyg_RealTimeClock实例对象Cyg_RealTimeClock::rtc，内核API通过该实例实现嘀嗒定时器相关特性。

class Cyg_RealTimeClock : public Cyg_Clock(1)
{
    Cyg_Interrupt       interrupt;(2)

    static cyg_uint32   isr(cyg_vector vector, CYG_ADDRWORD data);(3)
    static void         dsr(cyg_vector vector, cyg_ucount32 count, CYG_ADDRWORD data);

    Cyg_RealTimeClock();

    static Cyg_RealTimeClock rtc;(4)
};
Cyg_RealTimeClock Cyg_RealTimeClock::rtc CYG_INIT_PRIORITY( CLOCK );(5)

(1)	`Cyg_RealTimeClock`继承自`Cyg_Clock`， `Cyg_Clock`继承自`Cyg_Counter`。
(2)	嘀嗒定时器的中断实例。
(3)	ISR和DSR函数。
(4)	全局的`Cyg_RealTimeClock`实例，这里将其声明为`Cyg_RealTimeClock`类自身的静态变量，因此通过`Cyg_RealTimeClock`::rtc引用。
(5)	Cyg_RealTimeClock::rtc在这里定义。

Cyg_RealTimeClock::Cyg_RealTimeClock()(1)
    : Cyg_Clock(rtc_resolution),
      interrupt(CYGNUM_HAL_INTERRUPT_RTC,
                CYGNUM_KERNEL_COUNTERS_CLOCK_ISR_PRIORITY,
                (CYG_ADDRWORD)this, isr, dsr)
{
    HAL_CLOCK_INITIALIZE( CYGNUM_KERNEL_COUNTERS_RTC_PERIOD );(2)

    interrupt.attach();(3)

    interrupt.unmask_interrupt(CYGNUM_HAL_INTERRUPT_RTC);(4)

    Cyg_Clock::real_time_clock = this;
}

(1)	`Cyg_RealTimeClock`构造函数，调用基类构造函数以及Cyg_Interrupt实例构造函数。
(2)	调用HAL提供的`HAL_CLOCK_INITIALIZE`初始化硬件。
(3)	安装中断服务ISR和DSR。
(4)	使能定时器中断，使能中断后不一定就能产生嘀嗒中断，因为CPU那里还有一个中断总开关。

cyg_uint32 Cyg_RealTimeClock::isr(cyg_vector vector, CYG_ADDRWORD data)(1)
{
    HAL_CLOCK_RESET( CYGNUM_HAL_INTERRUPT_RTC, CYGNUM_KERNEL_COUNTERS_RTC_PERIOD );(2)

    Cyg_Interrupt::acknowledge_interrupt(CYGNUM_HAL_INTERRUPT_RTC);

    return Cyg_Interrupt::CALL_DSR|Cyg_Interrupt::HANDLED;
}

(1)	嘀嗒定时器的ISR。（已删减非关键代码）
(2)	调用HAL提供的定时器复位宏，复位定时器，并重新初始化定时器的计数器值。

void Cyg_RealTimeClock::dsr(cyg_vector vector, cyg_ucount32 count, CYG_ADDRWORD data)(1)
{
    Cyg_RealTimeClock *rtc = (Cyg_RealTimeClock *)data;

    rtc->tick( count );(2)

}

(1)	嘀嗒定时器的DSR。（已删减非关键代码）
(2)	DSR仅调用`Cyg_Counter`基类的tick函数，嘀嗒定时器的关键特性是在`Cyg_Counter::tick`中实现的。

void Cyg_Counter::tick( cyg_uint32 ticks )(1)
{
    // Increment the counter in a loop so we process
    // each tick separately. This is easier than trying
    // to cope with a range of increments.

    while( ticks-- )(2)
    {
        Cyg_Scheduler::lock();(3)

        // increment the counter, note that it is
        // allowed to wrap.
        counter += increment;(4)

        // now check for any expired alarms

        Cyg_Alarm_List *alarm_list_ptr;     // pointer to list
        alarm_list_ptr = &alarm_list;

        // Now that we have the list pointer, we can use common code for
        // both list organizations.
        // With unsorted lists we must scan the whole list for
        // candidates. However, we must be careful here since it is
        // possible for the function of one alarm to add or remove
        // other alarms to/from this list. Having the list shift under
        // our feet in this way could be disasterous. We solve this by
        // restarting the scan from the beginning whenever we call an
        // alarm function.

        cyg_bool rescan = true;

        while( rescan )(5)
        {
            Cyg_DNode_T<Cyg_Alarm> *node = alarm_list_ptr->get_head();

            rescan = false;

            while( node != NULL )
            {
                Cyg_Alarm *alarm = CYG_CLASSFROMBASE( Cyg_Alarm, Cyg_DNode, node );
                Cyg_DNode_T<Cyg_Alarm> *next = alarm->get_next();

                CYG_ASSERTCLASS(alarm, "Bad alarm in counter list" );

                if( alarm->trigger <= counter )(6)
                {
                    alarm_list_ptr->remove(alarm);

                    if( alarm->interval != 0 )
                    {
                        // The alarm has a retrigger interval.
                        // Reset the trigger time and requeue
                        // the alarm.
                        alarm->trigger += alarm->interval;
                        add_alarm( alarm );
                    }
                    else alarm->enabled = false;

                    CYG_INSTRUMENT_ALARM( CALL, this, alarm );

                    // Call alarm function
                    alarm->alarm(alarm, alarm->data);

                    rescan = true;

                    break;
                }

                // If the next node is the head of the list, then we have
                // looped all the way around. The node == next test
                // catches the case where we only had one element to start
                // with.
                if( next == alarm_list_ptr->get_head() || node == next )
                    node = NULL;
                else
                    node = next;
            }
        }
        Cyg_Scheduler::unlock();
    }
}

(1)	`Cyg_Counter::tick`函数，已删减非关键代码，`Cyg_Counter::tick`将对计数器值进行累加，然后检查链接到该计数器的所有`Cyg_Alarm`实例，如果`Cyg_Alarm`实例的触发值小于等于当前计数器值，那么调用该`Cyg_Alarm`实例的回调函数。从这里可以看出`Cyg_Counter`和`Cyg_Alarm`是密切关联的两个类，因此这两个类互相把对方声明为友元类。
(2)	根据未处理嘀嗒中断的次数进行多次处理，eCos的DSR机制通过记录中断次数的方式保证中断不会丢失，即使在DSR未及时得到执行的情况下。
(3)	对调度器进行加锁，接下来开始访问共享数据，访问之前对调度器加锁以保护共享数据。
(4)	累加计数值，对嘀嗒定时器而言，increment = 1。
(5)	扫描所有链接到该计数器的`Cyg_Alarm`实例，链接到同一个计数器的`Cyg_Alarm`实例以链表的方式组织。
(6)	检查`Cyg_Alarm`实例的触发值是否小于等于当前计数器值，如果是，那么删除该`Cyg_Alarm`实例并调用该实例对应的回调函数。

6. 计数器溢出

细心的朋友可能已经注意到，在Cyg_Counter::tick函数中没有考虑计数器溢出回滚到0的问题，溢出是迟早会发生的事情呀！eCos使用了64位的无符号整数来存储计数器，假设1毫秒产生一次嘀嗒中断，也就是说每1毫秒，Cyg_Count::counter加1，那么经过0×10000000000000000 / 1000秒后将会溢出，换算成天数，那么是0×10000000000000000 / 1000 / 60 / 60 / 24天，等于213503982334天，等于584942417年，早晚会溢出的，但是那是差不多6亿年后的事情啦，反正我死都死啦，管不着啦！使用64位整数做计数器虽然占用更多的内存空间，但是算法简单许多，还算划得来。