summaryrefslogtreecommitdiff
path: root/components
diff options
context:
space:
mode:
Diffstat (limited to 'components')
-rw-r--r--components/drivers/hwtimer/README_CN.md98
-rw-r--r--components/drivers/hwtimer/SConscript8
-rw-r--r--components/drivers/hwtimer/hwtimer.c355
-rw-r--r--components/drivers/include/drivers/hwtimer.h78
-rw-r--r--components/drivers/include/rtdevice.h4
-rw-r--r--components/finsh/cmd.c1
6 files changed, 544 insertions, 0 deletions
diff --git a/components/drivers/hwtimer/README_CN.md b/components/drivers/hwtimer/README_CN.md
new file mode 100644
index 0000000000..fb3b4fa60a
--- /dev/null
+++ b/components/drivers/hwtimer/README_CN.md
@@ -0,0 +1,98 @@
+定时器设备
+===
+
+##功能
+---
+* 时间测量
+* 周期或单次执行回调函数
+
+##编译
+---
+1. 在rtconfig.h添加 `#define RT_USING_HWTIMER`
+
+##使用流程
+---
+1. 以读写方式打开设备
+2. 设置超时回调函数（如果需要）
+3. 根据需要设置定时模式（单次/周期）
+4. 设置计数频率（可选）
+5. 写入超时值，定时器随即启动
+6. 停止定时器（可选）
+7. 关闭设备（如果需要）
+
+应用参考 [hwtimer_test] (/examples/test/hwtimer\_test.c)
+
+##驱动编写指南
+---
+###操作接口
+
+```
+struct rt_hwtimer_ops
+{
+ void (*init)(struct rt_hwtimer_device *timer, rt_uint32_t state);
+ rt_err_t (*start)(struct rt_hwtimer_device *timer, rt_uint32_t cnt, rt_hwtimer_mode_t mode);
+ void (*stop)(struct rt_hwtimer_device *timer);
+ rt_uint32_t (*count_get)(struct rt_hwtimer_device *timer);
+ rt_err_t (*control)(struct rt_hwtimer_device *timer, rt_uint32_t cmd, void *args);
+};
+```
+
+* init - state <1 打开设备 0 关闭设备>
+* start - cnt <超时值> - mode <单次/周期>
+* stop - <停止计数>
+* count_get - <读取计数器值>
+* control - <设置计数频率 >
+
+###定时器特征信息
+
+```
+struct rt_hwtimer_info
+{
+ rt_int32_t maxfreq;
+ rt_int32_t minfreq;
+ rt_uint32_t maxcnt;
+ rt_uint8_t cntmode;
+ };
+```
+
+* maxfreq <设备支持的最大计数频率>
+* minfreq <设备支持的最小计数频率>
+* maxcnt <计数器最大计数值>
+* cntmode <递增计数/递减计数>
+
+###注册设备
+```
+static rt_hwtimer_t _timer0;
+int stm32_hwtimer_init(void)
+{
+ _timer0.info = &_info;
+ _timer0.ops = &_ops;
+
+ rt_device_hwtimer_register(&_timer0, "timer0", TIM2);
+
+ return 0;
+}
+```
+
+###定时器中断
+```
+void timer_irq_handler(void)
+{
+ //其它操作
+
+ rt_device_hwtimer_isr(&_timer0);
+}
+```
+
+##注意事项
+---
+
+<font color="#FF0000">可能出现定时误差</font>
+
+
+误差原因：
+
+假设计数器最大值0xFFFF，计数频率1Mhz，定时时间1秒又1微秒。
+
+由于定时器一次最多只能计时到65535us，对于1000001us的定时要求。
+可以50000us定时20次完成，此时将会出现计算误差1us。
diff --git a/components/drivers/hwtimer/SConscript b/components/drivers/hwtimer/SConscript
new file mode 100644
index 0000000000..534e04b6c0
--- /dev/null
+++ b/components/drivers/hwtimer/SConscript
@@ -0,0 +1,8 @@
+from building import *
+
+cwd = GetCurrentDir()
+src = Glob('*.c')
+CPPPATH = [cwd + '/../include']
+group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_HWTIMER'], CPPPATH = CPPPATH)
+
+Return('group')
diff --git a/components/drivers/hwtimer/hwtimer.c b/components/drivers/hwtimer/hwtimer.c
new file mode 100644
index 0000000000..22b8d6262c
--- /dev/null
+++ b/components/drivers/hwtimer/hwtimer.c
@@ -0,0 +1,355 @@
+/*
+ * File : hwtimer.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2015-08-31 heyuanjie87 first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+rt_inline rt_uint32_t timeout_calc(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
+{
+ float overflow;
+ float timeout;
+ rt_uint32_t counter;
+ int i, index;
+ float tv_sec;
+ float devi_min = 1;
+ float devi;
+
+ /* �Ѷ�ʱ�����ʱ��Ͷ�ʱʱ�任����� */
+ overflow = timer->info->maxcnt/(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;
+
+ return counter;
+}
+
+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;
+ timer->overflow = 0;
+
+ if (timer->ops->init)
+ {
+ timer->ops->init(timer, 1);
+ }
+ 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->init != RT_NULL)
+ {
+ timer->ops->init(timer, 0);
+ }
+ 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->maxcnt - 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_uint32_t t;
+ rt_hwtimer_mode_t opm = HWTIMER_MODE_PERIOD;
+ rt_hwtimer_t *timer;
+
+ timer = (rt_hwtimer_t *)dev;
+ if ((timer->ops->start == RT_NULL) || (timer->ops->stop == RT_NULL))
+ return 0;
+
+ if (size != sizeof(rt_hwtimerval_t))
+ return 0;
+
+ if ((timer->cycles <= 1) && (timer->mode == HWTIMER_MODE_ONESHOT))
+ {
+ opm = HWTIMER_MODE_ONESHOT;
+ }
+ timer->ops->stop(timer);
+ timer->overflow = 0;
+
+ t = timeout_calc(timer, (rt_hwtimerval_t*)buffer);
+ if (timer->ops->start(timer, t, opm) != RT_EOK)
+ size = 0;
+
+ return size;
+}
+
+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_STOP:
+ {
+ if (timer->ops->stop != RT_NULL)
+ {
+ timer->ops->stop(timer);
+ }
+ else
+ {
+ result = -RT_ENOSYS;
+ }
+ }
+ 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_Timer;
+ 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);
+}
diff --git a/components/drivers/include/drivers/hwtimer.h b/components/drivers/include/drivers/hwtimer.h
new file mode 100644
index 0000000000..24cec74d32
--- /dev/null
+++ b/components/drivers/include/drivers/hwtimer.h
@@ -0,0 +1,78 @@
+#ifndef __HWTIMER_H__
+#define __HWTIMER_H__
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Timer Control Command */
+typedef enum
+{
+ HWTIMER_CTRL_FREQ_SET = 0x01, /* set the count frequency */
+ HWTIMER_CTRL_STOP, /* stop timer */
+ HWTIMER_CTRL_INFO_GET, /* get a timer feature information */
+ HWTIMER_CTRL_MODE_SET /* Setting the timing mode(oneshot/period) */
+} rt_hwtimer_ctrl_t;
+
+/* Timing Mode */
+typedef enum
+{
+ HWTIMER_MODE_ONESHOT = 0x01,
+ HWTIMER_MODE_PERIOD
+} rt_hwtimer_mode_t;
+
+/* Time Value */
+typedef struct rt_hwtimerval
+{
+ rt_int32_t sec; /* second */
+ rt_int32_t usec; /* microsecond */
+} rt_hwtimerval_t;
+
+#define HWTIMER_CNTMODE_UP 0x01 /* increment count mode */
+#define HWTIMER_CNTMODE_DW 0x02 /* decreasing count mode */
+
+struct rt_hwtimer_device;
+
+struct rt_hwtimer_ops
+{
+ void (*init)(struct rt_hwtimer_device *timer, rt_uint32_t state);
+ rt_err_t (*start)(struct rt_hwtimer_device *timer, rt_uint32_t cnt, rt_hwtimer_mode_t mode);
+ void (*stop)(struct rt_hwtimer_device *timer);
+ rt_uint32_t (*count_get)(struct rt_hwtimer_device *timer);
+ rt_err_t (*control)(struct rt_hwtimer_device *timer, rt_uint32_t cmd, void *args);
+};
+
+/* Timer Feature Information */
+struct rt_hwtimer_info
+{
+ rt_int32_t maxfreq; /* the maximum count frequency timer support */
+ rt_int32_t minfreq; /* the minimum count frequency timer support */
+ rt_uint32_t maxcnt; /* counter maximum value */
+ rt_uint8_t cntmode; /* count mode (inc/dec) */
+};
+
+typedef struct rt_hwtimer_device
+{
+ struct rt_device parent;
+ const struct rt_hwtimer_ops *ops;
+ const struct rt_hwtimer_info *info;
+
+ rt_int32_t freq; /* counting frequency set by the user */
+ rt_int32_t overflow; /* timer overflows */
+ float period_sec;
+ rt_int32_t cycles; /* how many times will generate a timeout event after overflow */
+ rt_int32_t reload; /* reload cycles(using in period mode) */
+ rt_hwtimer_mode_t mode; /* timing mode(oneshot/period) */
+} rt_hwtimer_t;
+
+rt_err_t rt_device_hwtimer_register(rt_hwtimer_t *timer, const char *name, void *user_data);
+void rt_device_hwtimer_isr(rt_hwtimer_t *timer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h
index f4d967831c..475adebf80 100644
--- a/components/drivers/include/rtdevice.h
+++ b/components/drivers/include/rtdevice.h
@@ -370,6 +370,10 @@ rt_inline void rt_work_init(struct rt_work* work, void (*work_func)(struct rt_wo
#include "drivers/can.h"
#endif
+#ifdef RT_USING_HWTIMER
+#include "drivers/hwtimer.h"
+#endif
+
#ifdef __cplusplus
}
#endif
diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c
index 7d24a33d6a..c42b412f23 100644
--- a/components/finsh/cmd.c
+++ b/components/finsh/cmd.c
@@ -467,6 +467,7 @@ static long _list_device(struct rt_list_node *list)
"PM Pseudo Device",
"Pipe",
"Portal Device",
+ "Timer Device",
"Miscellaneous Device",
"Unknown"
};
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 22:51:32 +0000