RT-Thread-[求测试拍砖]微秒级定时器设备RT-Thread问答社区

[求测试拍砖]微秒级定时器设备

发布于 2015-08-31 16:12:22 浏览：4309 订阅该版

软件定时器一般为毫秒级，更精细的定时就需要启动硬件定时器。
为了统一这方面需求的应用层接口，特此献丑为大家奉上hwtimer设备。
由于个人理解见识有限，先发出来让大家提点意见。

//20150901更新
1. 换了一个更方便的设置时间的方式(用如下结构将超时值用秒和微秒表示)

```c
typedef struct rt_hwtimerval
{
    rt_int32_t sec;      
    rt_int32_t usec;     
} rt_hwtimerval_t;
```

//20150902更新
1. 设置定时器超时时计算最小误差

使用例程
```c
static rt_err_t timer_timeout_cb(rt_device_t dev, rt_size_t size)
{
    rt_kprintf("HT %d
", rt_tick_get());

return 0;
}

int hwtimer(int freq, int t)
{
    rt_err_t err;
    rt_hwtimerval_t val;
    rt_device_t dev = RT_NULL;
    rt_tick_t tick;
    rt_hwtimer_mode_t mode;

t = (t <= 0)? 5 : t;

if ((dev = rt_device_find(TIMER)) == RT_NULL)
    {
        rt_kprintf("No Device: %s
", TIMER);
        return -1;
    }

if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) != RT_EOK)
    {
        rt_kprintf("Open %s Fail
", TIMER);
    }

rt_device_set_rx_indicate(dev, timer_timeout_cb);
    /* 计数时钟设置(默认1Mhz或支持的最小计数频率) */
    err = rt_device_control(dev, HWTIMER_CTRL_FREQ_SET, &freq);
    if (err != RT_EOK)
    {
        rt_kprintf("Set Freq=%dhz Fail
", freq);
        goto EXIT;
    }

/* 设置定时器超时值 */
    val.sec = t;
    val.usec = t*4523;
    rt_kprintf("SetTime: Sec %d, Usec %d
", val.sec, val.usec);
    if (rt_device_write(dev, 0, &val, sizeof(val)) != sizeof(val))
    {
        rt_kprintf("SetTime Fail
");
        goto EXIT;
    }

/* 周期模式 */
    mode = HWTIMER_MODE_PERIOD;
    err = rt_device_control(dev, HWTIMER_CTRL_MODE_SET, &mode);
    /* 启动定时器 */
    tick = rt_tick_get();
    err = rt_device_control(dev, HWTIMER_CTRL_START, RT_NULL);
    rt_kprintf("Start Timer> Tick: %d
", tick);
    rt_kprintf("Sleep %d sec
", t);
    rt_thread_delay(t*RT_TICK_PER_SECOND);

/* 停止定时器 */
    err = rt_device_control(dev, HWTIMER_CTRL_STOP, RT_NULL);
    rt_kprintf("Timer Stoped
");
    /* 读取计数 */
    rt_device_read(dev, 0, &val, sizeof(val));
    rt_kprintf("Read: Sec = %d, Usec = %d
", val.sec, val.usec);

EXIT:
    err = rt_device_close(dev);
    rt_kprintf("Close %s
", TIMER);

return err;
}
```

stm32驱动参考
```c
static void NVIC_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

/* Enable the TIM5 global Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

static void timer_init(rt_hwtimer_t *timer)
{
    TIM_TypeDef *tim;

tim = (TIM_TypeDef *)timer->parent.user_data;

TIM_DeInit(tim);
    NVIC_Configuration();
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    TIM_CounterModeConfig(tim, TIM_CounterMode_Up);
}

static void timer_deinit(rt_hwtimer_t *timer)
{
    TIM_TypeDef *tim;

tim = (TIM_TypeDef *)timer->parent.user_data;
    TIM_DeInit(tim);
}

static void timer_start(rt_hwtimer_t *timer, rt_hwtimer_mode_t opmode)
{
    TIM_TypeDef *tim;
    uint16_t m;

tim = (TIM_TypeDef *)timer->parent.user_data;
    m = (opmode == HWTIMER_MODE_ONESHOT)? TIM_OPMode_Single : TIM_OPMode_Repetitive;
    TIM_SelectOnePulseMode(tim, m);
    TIM_Cmd(tim, ENABLE);
}

static void timer_stop(rt_hwtimer_t *timer)
{
    TIM_TypeDef *tim;

tim = (TIM_TypeDef *)timer->parent.user_data;
    TIM_Cmd(tim, DISABLE);
}

static rt_err_t timer_ctrl(rt_hwtimer_t *timer, rt_uint32_t cmd, void *arg)
{
    TIM_TypeDef *tim;
    rt_err_t err = RT_EOK;

tim = (TIM_TypeDef *)timer->parent.user_data;

switch (cmd)
    {
    case HWTIMER_CTRL_FREQ_SET:
    {
        RCC_ClocksTypeDef clk;
        uint16_t val;
        rt_uint32_t freq;

RCC_GetClocksFreq(&clk);

freq = *((rt_uint32_t*)arg);
        clk.PCLK1_Frequency *= 2;
        val = clk.PCLK1_Frequency/freq;
        
		TIM_ITConfig(tim, TIM_IT_Update, DISABLE);
        TIM_PrescalerConfig(tim, val - 1, TIM_PSCReloadMode_Immediate);
		TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
		TIM_ITConfig(tim, TIM_IT_Update, ENABLE);
    }
    break;
    default:
    {
        err = -RT_ENOSYS;
    }
    break;
    }

return err;
}

static rt_uint32_t timer_counter_get(rt_hwtimer_t *timer)
{
    TIM_TypeDef *tim;

tim = (TIM_TypeDef *)timer->parent.user_data;

return TIM_GetCounter(tim);
}

static rt_err_t timer_timeout_set(rt_hwtimer_t *timer, rt_uint32_t t)
{
    TIM_TypeDef *tim;

tim = (TIM_TypeDef *)timer->parent.user_data;
    TIM_SetAutoreload(tim, t);

return RT_EOK;
}

static const struct rt_hwtimer_info _info =
{
    1000000,           /* 可设置的最大计数时钟 */
    2000,              /* 可设置的最小计数时钟 */
    65536,             /* 最大超时值 */
    HWTIMER_CNTMODE_UP,/* 递增计数方式 */
};

static const struct rt_hwtimer_ops _ops =
{
    timer_init,
    timer_deinit,
    timer_start,
    timer_stop,
    timer_timeout_set,
    timer_counter_get,
    timer_ctrl,
};

static rt_hwtimer_t _timer0;

void stm32_hwtimer_init(void)
{
    _timer0.info = &_info;
    _timer0.ops  = &_ops;

rt_device_hwtimer_register(&_timer0, "timer0", TIM2);
}

void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
        rt_device_hwtimer_isr(&_timer0);
    }
}
```

框架层
```c
rt_inline rt_err_t timeout_set(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
{
    rt_err_t err;
    float overflow;
    float timeout;
    rt_uint32_t counter;
    int i, index;
    float tv_sec;
    float devi_min = 1;
    float devi;

if (timer->ops->stop != RT_NULL)
    {
        timer->ops->stop(timer);
    }
    else
    {
        return -RT_ENOSYS;
    }

/* 把定时器溢出时间和定时时间换算成秒 */
    overflow = timer->info->maxtimeout/(float)timer->freq;
    tv_sec = tv->sec + tv->usec/(float)1000000;

if (tv_sec < (1/(float)timer->freq))
    {
        /* 定时时间小于计数周期 */
        i = 0;
        timeout = 1/(float)timer->freq;
    }
    else
    {
        for (i = 1; i > 0; i ++)
        {
            timeout = tv_sec/i;

if (timeout <= overflow)
            {
                counter = timeout*timer->freq;
                devi = tv_sec - (counter/(float)timer->freq)*i;
                /* 计算最小误差 */
                if (devi > devi_min)
                {
                    i = index;
                    timeout = tv_sec/i;
                    break;
                }
                else if (devi == 0)
                {
                    break;
                }
                else if (devi < devi_min)
                {
                    devi_min = devi;
                    index = i;
                }
            }
        }
    }

timer->cycles = i;
    timer->reload = i;
    timer->period_sec = timeout;
    counter = timeout*timer->freq;

if (timer->ops->timeout_set != RT_NULL)
    {
        err = timer->ops->timeout_set(timer, counter);
    }

return err;
}

static rt_err_t rt_hwtimer_init(struct rt_device *dev)
{
    rt_err_t result = RT_EOK;
    rt_hwtimer_t *timer;

timer = (rt_hwtimer_t *)dev;
    /* 尝试将默认计数频率设为1Mhz */
    if ((1000000 <= timer->info->maxfreq) && (1000000 >= timer->info->minfreq))
    {
        timer->freq = 1000000;
    }
    else
    {
        timer->freq = timer->info->minfreq;
    }
    timer->mode = HWTIMER_MODE_ONESHOT;
    timer->cycles = 0;

if (timer->ops->init)
    {
        timer->ops->init(timer);
    }
    else
    {
        result = -RT_ENOSYS;
    }

return result;
}

static rt_err_t rt_hwtimer_open(struct rt_device *dev, rt_uint16_t oflag)
{
    rt_err_t result = RT_EOK;
    rt_hwtimer_t *timer;

timer = (rt_hwtimer_t *)dev;
    if (timer->ops->control != RT_NULL)
    {
        timer->ops->control(timer, HWTIMER_CTRL_FREQ_SET, &timer->freq);
    }
    else
    {
        result = -RT_ENOSYS;
    }

return result;
}

static rt_err_t rt_hwtimer_close(struct rt_device *dev)
{
    rt_err_t result = RT_EOK;
    rt_hwtimer_t *timer;

timer = (rt_hwtimer_t*)dev;
    if (timer->ops->deinit != RT_NULL)
    {
        timer->ops->deinit(timer);
    }
    else
    {
        result = -RT_ENOSYS;
    }

dev->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
    dev->rx_indicate = RT_NULL;

return result;
}

static rt_size_t rt_hwtimer_read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
{
    rt_hwtimer_t *timer;
    rt_hwtimerval_t tv;
    rt_uint32_t cnt;
    float t;

timer = (rt_hwtimer_t *)dev;
    if (timer->ops->count_get == RT_NULL)
        return 0;

cnt = timer->ops->count_get(timer);
    if (timer->info->cntmode == HWTIMER_CNTMODE_DW)
    {
        cnt = timer->info->maxtimeout - cnt;
    }

t = timer->overflow * timer->period_sec + cnt/(float)timer->freq;
    tv.sec = t;
    tv.usec = (t - tv.sec) * 1000000;
    size = size > sizeof(tv)? sizeof(tv) : size;
    rt_memcpy(buffer, &tv, size);

return size;
}

static rt_size_t rt_hwtimer_write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    rt_size_t len = 0;
    rt_hwtimerval_t *t;
    rt_err_t err;

if (size == sizeof(rt_hwtimerval_t))
    {
        t = (rt_hwtimerval_t*)buffer;
        err = timeout_set((rt_hwtimer_t*)dev, t);
        if (err == RT_EOK)
        {
            len = size;
        }
    }

return len;
}

static rt_err_t rt_hwtimer_control(struct rt_device *dev, rt_uint8_t cmd, void *args)
{
    rt_err_t result = RT_EOK;
    rt_hwtimer_t *timer;

timer = (rt_hwtimer_t *)dev;

switch (cmd)
    {
    case HWTIMER_CTRL_START:
    {
        if (timer->ops->start != RT_NULL)
        {
            rt_hwtimer_mode_t opm;

if ((timer->cycles <= 1) && (timer->mode == HWTIMER_MODE_ONESHOT))
            {
                opm = HWTIMER_MODE_ONESHOT;
            }
            else
            {
                opm = HWTIMER_MODE_PERIOD;
            }

timer->overflow = 0;

timer->ops->start(timer, opm);
        }
        else
        {
            result = -RT_ENOSYS;
        }
    }
    break;
    case HWTIMER_CTRL_STOP:
    {
        if (timer->ops->stop != RT_NULL)
        {
            timer->ops->stop(timer);
        }
        else
        {
            result = -RT_ENOSYS;
        }
    }
    break;
    case HWTIMER_CTRL_TIMEOUT_SET:
    {
        if (args == RT_NULL)
        {
            result = -RT_EEMPTY;
            break;
        }

result = timeout_set(timer, (rt_hwtimerval_t*)args);
    }
    break;
    case HWTIMER_CTRL_FREQ_SET:
    {
        rt_uint32_t *f;

if (args == RT_NULL)
        {
            result = -RT_EEMPTY;
            break;
        }

f = (rt_uint32_t*)args;
        if ((*f > timer->info->maxfreq) || (*f < timer->info->minfreq))
        {
            result = -RT_ERROR;
            break;
        }

if (timer->ops->control != RT_NULL)
        {
            result = timer->ops->control(timer, cmd, args);
            if (result == RT_EOK)
            {
                timer->freq = *f;
            }
        }
        else
        {
            result = -RT_ENOSYS;
        }
    }
    break;
    case HWTIMER_CTRL_INFO_GET:
    {
        if (args == RT_NULL)
        {
            result = -RT_EEMPTY;
            break;
        }

*((struct rt_hwtimer_info*)args) = *timer->info;
    }
    case HWTIMER_CTRL_MODE_SET:
    {
        rt_hwtimer_mode_t *m;

if (args == RT_NULL)
        {
            result = -RT_EEMPTY;
            break;
        }

m = (rt_hwtimer_mode_t*)args;

if ((*m != HWTIMER_MODE_ONESHOT) && (*m != HWTIMER_MODE_PERIOD))
        {
            result = -RT_ERROR;
            break;
        }

timer->mode = *m;
    }
    break;
    default:
    {
        result = -RT_ENOSYS;
    }
    break;
    }

return result;
}

void rt_device_hwtimer_isr(rt_hwtimer_t *timer)
{
    RT_ASSERT(timer != RT_NULL);

timer->overflow ++;

if (timer->cycles != 0)
    {
        timer->cycles --;
    }

if (timer->cycles == 0)
    {
        timer->cycles = timer->reload;

if (timer->mode == HWTIMER_MODE_ONESHOT)
        {
            if (timer->ops->stop != RT_NULL)
            {
                timer->ops->stop(timer);
            }
        }

if (timer->parent.rx_indicate != RT_NULL)
        {
            timer->parent.rx_indicate(&timer->parent, sizeof(struct rt_hwtimerval));
        }
    }
}

rt_err_t rt_device_hwtimer_register(rt_hwtimer_t *timer, const char *name, void *user_data)
{
    struct rt_device *device;

RT_ASSERT(timer != RT_NULL);
    RT_ASSERT(timer->ops != RT_NULL);
    RT_ASSERT(timer->info != RT_NULL);

device = &(timer->parent);

device->type        = RT_Device_Class_HwTimer;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

device->init        = rt_hwtimer_init;
    device->open        = rt_hwtimer_open;
    device->close       = rt_hwtimer_close;
    device->read        = rt_hwtimer_read;
    device->write       = rt_hwtimer_write;
    device->control     = rt_hwtimer_control;
    device->user_data   = user_data;

return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
}
```

测试工程(hwtimer_test.c)
http://pan.baidu.com/s/1eQ8mzh4