嵌入式Linux脉冲计数编码器驱动编写

近期做一个项目需要用到编码器功能，发现正点原子im6ull的linux嵌入式开发板没有脉冲计数功能haha，那就根据GPIO中断功能自己写一个，废话不多说直接开搞，有帮助的小伙伴请务必转发关注haha

一、设计思路

编码器获取速度或流量主要分为两个部分：①脉冲计数②定时读取

其中①脉冲计数在驱动中实现，每读取一次脉冲数将脉冲数清零，由于不需要捕获脉宽，只需要设置上升沿触发即可

②定时读取在应用层实现，使用定时器中断实现

最后，用(脉冲数/定时间隔)即可得到速度or流量的数字量大小

二、Coding

①首先，修改设备树，设备树中添加如下内容：

以GPIO1-2为例，根据自己板子上的外设资源修改设备树

encoder {
  compatible = "atkalpha-encoder";
  pinctrl-names = "default";
  pinctrl-0 = <&pinctrl_encoder>;
  encoder-gpio = <&gpio1 2 GPIO_ACTIVE_LOW>;
  interrupt-parent = <&gpio1>;
  interrupts = <2 IRQ_TYPE_EDGE_RISING>; 	/* 上升沿触发 */
  status = "okay";
};

②编写encoder驱动：

其中 encoder设备结构体中的脉冲数cnt需要用atomic_t原子量声明：atomic_t cnt，防止读写过程中发生读写操作发生在同一变量上。

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>


#define ENCODER_CNT		1			/* 设备号个数 	*/
#define ENCODER_NAME	"encoder_irq"	/* 名字 		*/
#define GPIO_NUM		1			/* 按键数量 	*/


/* 中断IO描述结构体 */
struct encoder_desc {
	int gpio;								/* gpio */
	int irqnum;								/* 中断号     */
	char name[20];							/* 名字 */
	irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
};

/* encoder设备结构体 */
struct encoder_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	atomic_t cnt;			/* 脉冲数 */
	struct encoder_desc irqdesc[GPIO_NUM];	/* 按键描述数组 */
};

struct encoder_dev encoder;	/* irq设备 */

/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t encoder_handler(int irq, void *dev_id)
{
	struct encoder_dev *dev = (struct encoder_dev *)dev_id;

	atomic_inc(&dev->cnt);

	return IRQ_RETVAL(IRQ_HANDLED);
}


/*
 * @description	: 按键IO初始化
 * @param 		: 无
 * @return 		: 无
 */
static int gpio_init(void)
{
	unsigned char i = 0;
	int ret = 0;

	encoder.nd = of_find_node_by_path("/encoder");
	if (encoder.nd== NULL){
		printk("encoder node not find!\r\n");
		return -EINVAL;
	}

	/* 提取GPIO */
	for (i = 0; i < GPIO_NUM; i++) {
		encoder.irqdesc[i].gpio = of_get_named_gpio(encoder.nd ,"encoder-gpio", i);
		if (encoder.irqdesc[i].gpio < 0) {
			printk("can't get encoder%d\r\n", i);
		}
	}

	/* 初始化所使用的IO，并且设置成中断模式 */
	for (i = 0; i < GPIO_NUM; i++) {
		memset(encoder.irqdesc[i].name, 0, sizeof(encoder.irqdesc[i].name));	/* 缓冲区清零 */
		sprintf(encoder.irqdesc[i].name, "encoder_gpio%d", i);		/* 组合名字 */
		gpio_request(encoder.irqdesc[i].gpio, encoder.irqdesc[i].name);
		gpio_get_value(encoder.irqdesc[i].gpio);
		encoder.irqdesc[i].irqnum = irq_of_parse_and_map(encoder.nd, i);
#if 0
		encoder.irqdesc[i].irqnum = gpio_to_irq(encoder.irqdesc[i].gpio);
#endif
		printk("encoder_gpio%d:gpio=%d, irqnum=%d\r\n",i, encoder.irqdesc[i].gpio,
                                         encoder.irqdesc[i].irqnum);
	}
	/* 申请中断 */
	encoder.irqdesc[0].handler = encoder_handler;

	for (i = 0; i < GPIO_NUM; i++) {
		ret = request_irq(encoder.irqdesc[i].irqnum, encoder.irqdesc[i].handler,
							IRQF_TRIGGER_RISING, encoder.irqdesc[i].name, &encoder);
		if(ret < 0){
			printk("irq %d request failed!\r\n", encoder.irqdesc[i].irqnum);
			return -EFAULT;
		}
	}

	return 0;
}


static int encoder_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &encoder;	/* 设置私有数据 */
	return 0;
}

 /*
  * @description     : 从设备读取数据
  * @param - filp    : 要打开的设备文件(文件描述符)
  * @param - buf     : 返回给用户空间的数据缓冲区
  * @param - cnt     : 要读取的数据长度
  * @param - offt    : 相对于文件首地址的偏移
  * @return          : 读取的字节数，如果为负值，表示读取失败
  */
static ssize_t encoder_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int ret = 0;
	int flow = 0;
	struct encoder_dev *dev = (struct encoder_dev *)filp->private_data;

	// 读取脉冲数
	flow = atomic_read(&dev->cnt);

	ret = copy_to_user(buf, &flow, sizeof(flow));
	// 脉冲数清零
	atomic_set(&dev->cnt, 0);

	return ret;
}

/* 设备操作函数 */
static struct file_operations encoder_fops = {
	.owner = THIS_MODULE,
	.open = encoder_open,
	.read = encoder_read,
};

/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init encoder_init(void)
{
	/* 1、构建设备号 */
	if (encoder.major) {
		encoder.devid = MKDEV(encoder.major, 0);
		register_chrdev_region(encoder.devid, ENCODER_CNT, ENCODER_NAME);
	} else {
		alloc_chrdev_region(&encoder.devid, 0, ENCODER_CNT, ENCODER_NAME);
		encoder.major = MAJOR(encoder.devid);
		encoder.minor = MINOR(encoder.devid);
	}

	/* 2、注册字符设备 */
	cdev_init(&encoder.cdev, &encoder_fops);
	cdev_add(&encoder.cdev, encoder.devid, ENCODER_CNT);

	/* 3、创建类 */
	encoder.class = class_create(THIS_MODULE, ENCODER_NAME);
	if (IS_ERR(encoder.class)) {
		return PTR_ERR(encoder.class);
	}

	/* 4、创建设备 */
	encoder.device = device_create(encoder.class, NULL, encoder.devid, NULL, ENCODER_NAME);
	if (IS_ERR(encoder.device)) {
		return PTR_ERR(encoder.device);
	}

	/* 5、初始化按键 */
	atomic_set(&encoder.cnt, 0);
	gpio_init();
	return 0;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit encoder_exit(void)
{
	unsigned int i = 0;

	/* 释放中断 */
	for (i = 0; i < GPIO_NUM; i++) {
		free_irq(encoder.irqdesc[i].irqnum, &encoder);
		gpio_free(encoder.irqdesc[i].gpio);
	}
	cdev_del(&encoder.cdev);
	unregister_chrdev_region(encoder.devid, ENCODER_CNT);
	device_destroy(encoder.class, encoder.devid);
	class_destroy(encoder.class);
}

module_init(encoder_init);
module_exit(encoder_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("harifiri");

Makefile文件为：

KERNELDIR := /home/harifiri/IMX6ULL/linux //编译所用的linux内核位置
CURRENT_PATH := $(shell pwd)

obj-m := encoder.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

执行make命令得到encoder.ko驱动文件

然后挂载encoder驱动：

depmod
modprobe encoder

②编写应用层APP<encoderAPP.c>，这里是每1s读取一次脉冲数量

#include <signal.h>
#include <time.h>
#include <stdio.h>


void timer_handler()
{
	int fd;
	int ret = 0;
	char *filename;
	int data;

	filename = "/dev/encoder_irq";
	fd = open(filename, O_RDWR);
	if (fd < 0) {
		printf("Can't open file %s\r\n", filename);
		return -1;
	}

   ret = read(fd, &data, sizeof(data));
   if (ret < 0) {  /* 数据读取错误或者无效 */
       printf("encoder read err\r\n");
   }
   else {		/* 数据读取正确 */
       printf("encoder value = %#d\r\n", data);
   }

	return;
}


int timer_init(void)
{
    int ret = 0;

    struct sigevent evp;
    struct itimerspec ts;
    timer_t timer;

    evp.sigev_value.sival_ptr = &timer;
    evp.sigev_notify = SIGEV_SIGNAL;
    evp.sigev_signo = SIGUSR1;
    signal(SIGUSR1, timer_handler);
    ret = timer_create(CLOCK_REALTIME, &evp, &timer);
    if( ret ){
        perror("timer_create");
        return ret;
    }
    ts.it_interval.tv_sec = 1;
    ts.it_interval.tv_nsec = 0;
    ts.it_value.tv_sec = 0;
    ts.it_value.tv_nsec = 0;
    ret = timer_settime(timer, 0, &ts, NULL);
    if( ret ){
        perror("timer_settime");
        return ret;
    }


    return 0;
}

然后交叉编译得到encoderAPP

arm-linux-gnueabihf-gcc encoderAPP.c -o encoderAPP

最后，执行

./encoderAPP

DONE，完结撒花