Linux内核定时器使用及说明

struct timer_list {
       struct hlist_node entry;                                    //实现定时器结构链表化管理
       unsigned long             expires;                          //到期时间点      不是时长
       void                     (*function)(unsigned long);        //超时处理函数
       unsigned long             data;
       u32               flags;
       int                 slack;
};

unsigned long msecs_to_jiffies(const unsigned int m)             //把ms转换为时钟节拍
unsigned long usecs_to_jiffies(const unsigned int u)             //把us转换为时钟节拍

struct timer_list btn_timer;
setup_timer(&btn_timer, fn, data)
btn_timer.expires = jiffies+定时时长对应的时钟节拍数;
启动定时器。。。

struct timer_list timer,
……
add_timer(&timer);
add_timer(&timer);
……

#include<linux/module.h>
#include<linux/init.h>
#include<linux/timer.h>

static void timer_func(unsigned long data);

//静态定义：定义并且初始化
DEFINE_TIMER(my_timer,timer_func,0,(unsigned long)"LIU");

//定时器超时函数
static void timer_func(unsigned long data)
{
	printk("data：%s\r\n",(char *)data);
	//启动新一次定时，实现循环定时
	mod_timer(&my_timer,jiffies + 2*HZ);
}

static int __init timer_list_init(void)
{
	//重新初始化到期时间
	my_timer.expires = jiffies + 2*HZ;	//2s
	
	//马上启动定时器
	printk("-----begin------\r\n");
	add_timer(&my_timer);
	printk("------end-------\r\n");
    return 0; 
}

static void __exit timer_list_exit(void)
{
	//删除定时器
	del_timer_sync(&my_timer);
}

module_init(timer_list_init);			// 指定模块初始化函数
module_exit(timer_list_exit);			// 指定模块清理函数
MODULE_LICENSE("GPL");					// 声明模块许可证（GPL v2） 

#include<linux/module.h>
#include<linux/init.h>
#include<linux/timer.h>

static void timer_func(unsigned long data);

//静态定义：定义并且初始化
DEFINE_TIMER(my_timer,timer_func,0,(unsigned long)"Time out");

//定时器超时函数
static void timer_func(unsigned long data)
{
	printk("data：%s\r\n",(char *)data);
	//启动新一次定时，实现循环定时
	mod_timer(&my_timer,jiffies + 2*HZ);
}

static int __init timer_list_init(void)
{
	//重新初始化到期时间
	my_timer.expires = jiffies + 2*HZ;	//2s
	
	//马上启动定时器
	printk("-----begin------\r\n");
	add_timer(&my_timer);
	printk("------end-------\r\n");
    return 0; 
}

static void __exit timer_list_exit(void)
{
	//删除定时器
	del_timer_sync(&my_timer);
}

module_init(timer_list_init);			// 指定模块初始化函数
module_exit(timer_list_exit);			// 指定模块清理函数
MODULE_LICENSE("GPL");					// 声明模块许可证（GPL v2） 

#include <linux/module.h>
#include <linux/init.h>
#include <linux/timer.h>

//全局驱动数据
struct drv_data{
	struct timer_list timer;
	char *data;
	u64 expires;
};
static struct drv_data gvar;

//定时器超时处理函数
static void timer_func(unsigned long data)
{
	struct drv_data *pdata = (struct drv_data *)data;
	printk("data：%s\r\n",pdata->data);
	//启动新一次定时，实现循环定时
	mod_timer(&pdata->timer,jiffies + pdata->expires);
}

static int __init timer_list_init(void)
{
	//普通成员初始化
	gvar.data    = "Time out";
	gvar.expires = 2*HZ;
	
	//初始化定时器
	setup_timer(&gvar.timer,timer_func, (unsigned long)&gvar);
	
	//重新初始化到期时间
	gvar.timer.expires = jiffies + gvar.expires;	//2s
	
	//马上启动定时器
	printk("-----begin------\r\n");
	add_timer(&gvar.timer);
	printk("------end-------\r\n");
    return 0; 
}

static void __exit timer_list_exit(void)
{
	//删除定时器
	del_timer_sync(&gvar.timer);
}
module_init(timer_list_init);			// 指定模块初始化函数
module_exit(timer_list_exit);			// 指定模块清理函数
MODULE_LICENSE("GPL");					// 声明模块许可证（GPL v2） 

//增加内核定时器功能
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/miscdevice.h>
#include<asm/uaccess.h>
#include<linux/interrupt.h>
#include<linux/irq.h>
#include<linux/gpio.h>
#include<linux/slab.h>

#define LEDS_MINOR	255
#define DEVICE_NAME  "my-buttons" // 设备节点名称，将在/dev目录下创建 

#ifndef ARRAYSIZE
#define ARRAYSIZE(a)	(sizeof(a)/sizeof(a[0]))
#endif

//按键数量,在模块初始化函数中进行计算
static int key_size;
//按键缓冲区，一个元素存放一个按键值，'1'表示按下，'0'表示松开
//在模块的初始化函数中分配缓冲区空间
static char *keys_buf;	

//使用面向对象思想设计按键，把一个按键信息进行封装
struct key_info{
	int id;					//按键编号
	int gpio;				//统一的GPIO编号
	unsigned long flags;	//触发方式
	char *name;				//按键名
	int irq;				//中断编号
	struct timer_list timer;//增加一个定时器作消抖
};

//实例化对象
static struct key_info keys[]={
	[0]={
		.id 	= 0,
		.gpio 	= 5,
		.flags 	= IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
		.name 	= "key-0",
	},
	[1]={
		.id 	= 0,
		.gpio 	= 54,
		.flags 	= IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
		.name 	= "key-1",
	},	
};

static int key_open (struct inode *pinode, struct file *pfile)
{
    printk("line:%d,%s is call\n",__LINE__,__FUNCTION__);
    return 0;    
}

loff_t key_llseek (struct file *pfile, loff_t offset, int whence)
{
    return 0;    
}

static ssize_t key_read (struct file *pfile, char __user *buf, size_t count, loff_t *offset)    
{
    int ret;
	if(count > key_size)	count = key_size;
    if(count == 0)			return 0;
	
	//准备数据，但是按键数据在中断中实时更新，不需要在这里读取
	//复制数据到用户空间
	ret = copy_to_user(buf, keys_buf, count);
	if(ret){
		printk("error:copy_to_user\r\n");
		ret = -EFAULT;
		goto errot_copy_to_user;
	}
	return count;  // 返回成功读取的字节数  
errot_copy_to_user:
	return ret;
}

int key_release (struct inode *pinode, struct file *pfile)
{
    return 0;
}

// 文件操作结构体（关联实现的操作函数） 
static const struct file_operations dev_fops = {
    .open = key_open,      // 打开设备 
    .read = key_read,      // 读取设备状态 
	.owner = THIS_MODULE,
};

// 杂项设备定义 
static struct miscdevice key_device = {
    .name = DEVICE_NAME,	// 设备名称（出现在/dev目录下） 
    .minor = LEDS_MINOR, 	// 次设备号（建议使用动态分配） 
    .fops = &dev_fops,		// 关联文件操作函数集 
};

//超时处理函数
void btn_timer(unsigned long data)
{

	int s;
	struct key_info *pdata = (struct key_info *)data;

	//检测当前的电平状态
	s = !gpio_get_value(pdata->gpio);
	keys_buf[pdata->id]='0'+s;	//保存状态
}

//按键中断函数
//设置了双边触发，按下和松开都会进入这个函数
irqreturn_t btns_irq_handler(int irq,void *devid)
{
	struct key_info *pdata = (struct key_info *)devid;

	//启动新一次定时
	mod_timer(&pdata->timer,jiffies + msecs_to_jiffies(20));
	return IRQ_HANDLED;
}

static int __init xyd_btn_init(void)
{
    int ret,i;

	key_size = ARRAY_SIZE(keys);	//计算按键数量

	//分配按键缓冲区
	keys_buf = kzalloc(key_size,GFP_KERNEL);
	if(keys_buf == NULL)
		return -EFAULT;
	
	//循环注册中断
	for(i = 0;i < key_size;i++){
		keys[i].irq = gpio_to_irq(keys[i].gpio);
		if(keys[i].irq < 0)
		{
			printk("error:gpio_to_irq\r\n");
			goto error_gpio_to_irq;  
		}
		printk("irq：%d\r\n",keys[i].irq);
		
		//传递每个按键结构变量地址，发生中断时可以通过参数取得
		ret = request_irq(keys[i].irq, btns_irq_handler, keys[i].flags, keys[i].name, (void *)&keys[i]);
		if(ret < 0)
		{
			printk("error:request_irq\r\n");
			goto error_request_irq;  
		}

		//初始化按键的定时器,参数是按键自身的结构内存地址
		setup_timer(&keys[i].timer,btn_timer, (unsigned long)&keys[i]);
	}
    ret = misc_register(&key_device);
    if(ret < 0){
        printk("error:misc_register\r\n");
        goto error_misc_register;  
    }
    return 0;  								// 初始化成功 

error_misc_register:
error_request_irq:
	while(--i >= 0){
		free_irq(keys[i].irq, (void *)&keys[i]);	//注销中断
	}
	
error_gpio_to_irq:
	kfree(keys_buf);		//释放按键缓冲区空间
    return ret; 
}

static void __exit key_btn_exit(void)
{
	int i = key_size;
	while(--i >= 0){
		free_irq(keys[i].irq, (void *)&keys[i]);	//注销中断
	}
	misc_deregister(&key_device);	//注销杂项设备
	kfree(keys_buf);				//释放按键缓冲区空间
}

module_init(xyd_btn_init);		  								// 指定模块初始化函数 
module_exit(key_btn_exit);  									// 指定模块清理函数 
MODULE_LICENSE("GPL");											// 声明模块许可证（GPL v2） 
MODULE_AUTHOR("LIU");    										// 模块作者 
MODULE_DESCRIPTION("RK3399 GPIO KEY Control Driver"); 			// 模块描述 

#include<stdio.h>              // 标准输入输出库（printf, perror等）
#include<stdlib.h> 
#include<string.h> 
#include<sys/types.h>          // 系统数据类型定义（如dev_t）
#include<sys/stat.h>           // 文件状态信息（文件模式等）
#include<fcntl.h>              // 文件控制选项（open等）
#include<unistd.h>             // 系统调用封装（lseek, read, write, sleep等）
#include<sys/ioctl.h>          // I/O控制操作（ioctl）
#include<errno.h> 

#define BTN_SIZE	1					// 按键数量
#define DEV_NAME 	"/dev/my-buttons"  	// 默认设备名

int main(int argc, char **argv)
{
    int fd,ret, i;                
    const char *devname; 				// 设备路径指针（初始化为默认路径）
    unsigned char pre_buf[BTN_SIZE+1],recv_buf[BTN_SIZE+1];

	memset(pre_buf,'0',BTN_SIZE);
	memset(recv_buf,'0',BTN_SIZE);
	
    if(argc == 1) 
        devname = DEV_NAME;
    else if(argc == 2)
        devname= argv[1];
    else {
        printf("Usage:%s [/dev/devname]\r\n", argv[0]);
        return 0;
    }

    fd = open(devname, O_RDWR);  			// O_RDWR：以读写模式打开
    if(fd < 0) {
        perror("open");   					// 打印系统错误信息
        printf("fd=%d\r\n", fd);
        return -1;            				// 打开失败退出程序
    }
    printf("fd=%d\r\n", fd);  				// 成功打开后输出fd值

    while(1) {
		ret = read(fd,recv_buf,BTN_SIZE);	// 读取按键数据
		if(ret < 0){
			if(errno != EAGAIN){
				perror("read");
				exit(-1);
			}else	continue;
		}

		//只在状态发生变化时候才输出
		for(i = 0;i < BTN_SIZE;i++){
			//分别判断每一个按键状态是否发生变化
			if(recv_buf[i] != pre_buf[i]){
				//更新当前状态为上一次状态
				pre_buf[i] = recv_buf[i];

				//判断这次变化是按下还是松开
				if(pre_buf[i] == '1')	printf("KEY%d is press!\r\n",i+1);
				else					printf("KEY%d is up!\r\n",i+1);
			}
		}
    }    
    return 0;
}