首页 > 系统相关 >【Linux】TCS34725 颜色传感器设备驱动

【Linux】TCS34725 颜色传感器设备驱动

时间：2023-01-07 10:44:35浏览次数：61  
标签：return ret tcs3472x dev 传感器 Linux TCS34725 i2c

一、概述

此笔记主要是学习 Linux 中的 I2C 驱动，顺便验证一下 TCS34725 传感器的使用，主要内容还是程序记录，方便编写其他 I2C 设备驱动时做参考，所以关于 TCS34725 这里就不过多描述了，需要的小伙伴可以浏览我之前的笔记：TCS34725 颜色传感器设备驱动程序

二、添加 I2C 设备

学习到 I2C 驱动的小伙伴应该都知道平台设备这个概念了，所以这里需要使用到 I2C 总线，由于 I2C 总线驱动基本都是由板子厂商帮我们移植好的，所以这里就不关注 I2C 总线驱动了，有需要的小伙伴自行了解。

添加设备也有两种方式，这里我以设备树的形式添加设备为例，传统的添加方式相比设备树比较麻烦一些，这里就跳过这部分类容。

  1. 打开设备树文件，向 I2C 节点中追加 TCS34725 传感器的设备信息，如下所示：

    &i2c0{
    rgb_colour@29{
        compatible = "colour,tcs34725";
        reg = <0x29>;
    };
};

    注意：在&i2c0的i2c0一定是i2c设备节点的标签，我尝试使用节点名称引用，发现编译不通过，所以当你设备树中的i2c节点没有标签的话，自行添加一个。当然也是可以直接添加到i2c设备节点中的。

  2. 编译设备树，并烧写设备树文件

  3. 查看设备节点是否添加成功
    通过命令 ls /sys/bus/i2c/devices/ 查看 I2C 设备，其中 0-0029 就是我们添加的设备，可以通过设备的 name 属性查看设备的名称，如下图所示：

    注意：图中的中 name 属性变量，就是在设备树中添加的 compatible 属性，也是 I2C 总线用于匹配设备驱动时的匹配名称。

三、I2C 设备驱动编写

为了方便测试，这里是以模块的形式加载驱动设备的，没有直接在内核文件中，所以测试时不用重新编译内核文件。

  1. 出入口函数
    这两个函数是模块的出入口函数，编写驱动模块是就少不了它两

    /* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(tcs3472x_driver_init);
module_exit(tcs3472x_driver_exit);

  2. 加载和卸载 I2C 设备
    通过 i2c_add_driver 和 i2c_del_driver 函数加载和卸载 I2C 设备的，代码如下所示：

    /**
 * @brief 驱动入口函数
 * @return 0，成功;其他负值,失败
*/
static int __init tcs3472x_driver_init(void)
{
	int ret;
	pr_info("tcs3472x_driver_init\n");
	ret = i2c_add_driver(&tcs3472x_driver);
	return ret;
}

/**
 * @brief 驱动出口函数
 * @return 0，成功;其他负值,失败
*/
static void __exit tcs3472x_driver_exit(void)
{
	pr_info("tcs3472x_driver_exit\n");
	i2c_del_driver(&tcs3472x_driver);
}

  3. 设备信息

    /* 传统匹配方式 ID 列表 */
static const struct i2c_device_id gtp_device_id[] = {
	{"colour,tcs34721", 0},
	{"colour,tcs34725", 0},
	{"colour,tcs34723", 0},
	{"colour,tcs34727", 0},
	{}};

/* 设备树匹配表 */
static const struct of_device_id tcs3472x_of_match_table[] = {
	{.compatible = "colour,tcs34721"},
	{.compatible = "colour,tcs34725"},
	{.compatible = "colour,tcs34723"},
	{.compatible = "colour,tcs34727"},
	{/* sentinel */}};

/* i2c总线设备结构体 */
struct i2c_driver tcs3472x_driver = {
	.probe = tcs3472x_probe,
	.remove = tcs3472x_remove,
	.id_table = gtp_device_id,
	.driver = {
		.name = "colour,tcs3472x",
		.owner = THIS_MODULE,
		.of_match_table = tcs3472x_of_match_table,
	},
};

    注意：

    • 设备树中的 compatible 属性会和匹配表中查找，当名称一样时，设备和驱动就匹配成功了。
    • 匹配成功时会调用 .probe 函数
    • 卸载模块是会调用 .remove 函数

  4. .probe 和 .remove 函数

    /**
 * @brief i2c 驱动的 probe 函数，当驱动与设备匹配以后此函数就会执行
 * @param client i2c 设备
 * @param id i2c 设备 ID
 * @return 0，成功;其他负值,失败
*/
static int tcs3472x_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret = -1; 						// 保存错误状态码
	struct tcs3472x_dev *tcs_dev;		// 设备数据结构体  

	/*---------------------注册字符设备驱动-----------------*/
	
	/* 驱动与总线设备匹配成功 */
	printk(KERN_EMERG "\t  %s match successed  \r\n", client->name);

	/* 申请内存并与 client->dev 进行绑定。*/
	/* 在 probe 函数中使用时，当设备驱动被卸载，该内存被自动释放，也可使用 devm_kfree() 函数直接释放 */
	tcs_dev = devm_kzalloc(&client->dev, sizeof(*tcs_dev), GFP_KERNEL);
	if(!tcs_dev)
	{
		pr_err("Failed to request memory \r\n");
		return -ENOMEM;
	}

	/* 1、创建设备号 */
	/* 采用动态分配的方式，获取设备编号，次设备号为0 */
	/* 设备名称为 TCS3472x_NAME，可通过命令 cat /proc/devices 查看 */
	/* TCS3472x_CNT 为1，只申请一个设备编号 */
	ret = alloc_chrdev_region(&tcs_dev->devid, 0, TCS3472x_CNT, TCS3472x_NAME);
	if (ret < 0)
	{
		pr_err("%s Couldn't alloc_chrdev_region, ret = %d \r\n", TCS3472x_NAME, ret);
		return -ENOMEM;
	}

	/* 2、初始化 cdev */
	/* 关联字符设备结构体 cdev 与文件操作结构体 file_operations */
	tcs_dev->cdev.owner = THIS_MODULE;
	cdev_init(&tcs_dev->cdev, &tcs3472x_ops);

	/* 3、添加一个 cdev */
	// 添加设备至cdev_map散列表中
	ret = cdev_add(&tcs_dev->cdev, tcs_dev->devid, TCS3472x_CNT);
	if (ret < 0)
	{
		pr_err("fail to add cdev \r\n");
		goto del_unregister;
	}

	/* 4、创建类 */
	tcs_dev->class = class_create(THIS_MODULE, TCS3472x_NAME);
	if (IS_ERR(tcs_dev->class)) 
	{
		pr_err("Failed to create device class \r\n");
		goto del_cdev;
	}

	/* 5、创建设备,设备名是 TCS3472x_NAME */
	/*创建设备 TCS3472x_NAME 指定设备名，*/
	tcs_dev->device = device_create(tcs_dev->class, NULL, tcs_dev->devid, NULL, TCS3472x_NAME);
	if (IS_ERR(tcs_dev->device)) {
		goto destroy_class;
	}
	tcs_dev->client = client;
	
	/* 保存 ap3216cdev 结构体 */
	i2c_set_clientdata(client, tcs_dev);

	return 0;

destroy_class:
	device_destroy(tcs_dev->class, tcs_dev->devid);
del_cdev:
	cdev_del(&tcs_dev->cdev);
del_unregister:
	unregister_chrdev_region(tcs_dev->devid, TCS3472x_CNT);
	return -EIO;
}

/**
 * @brief i2c 驱动的 remove 函数，移除 i2c 驱动的时候此函数会执行
 * @param client i2c 设备
 * @return 0，成功;其他负值,失败
*/
static int tcs3472x_remove(struct i2c_client *client)
{
	struct tcs3472x_dev *tcs_dev = i2c_get_clientdata(client);

	/*---------------------注销字符设备驱动-----------------*/

	/* 1、删除 cdev */
	cdev_del(&tcs_dev->cdev);
	/* 2、注销设备号 */
	unregister_chrdev_region(tcs_dev->devid, TCS3472x_CNT);
	/* 3、注销设备 */
	device_destroy(tcs_dev->class, tcs_dev->devid);
	/* 4、注销类 */
	class_destroy(tcs_dev->class);
	return 0;
}

    注意：从上面代码中可以看出，这里主要是字符设备的操作过程成，所以到这里就可以直接使用 file_operations 函数进行操作了。

  5. I2C 数据的读写

    /**
 * @brief 向 I2C 从设备的寄存器写入数据
 * 
 * @param client I2C 设备
 * @param reg 要写入的寄存器首地址
 * @param val 要写入的数据缓冲区
 * @param len 要写入的数据长度
 * @return 返回执行的结果
 */
static int i2c_write_regs(struct i2c_client *client, u8 reg, u8 *buf, u8 len)
{
	int ret = 0;
	u8 write_buf[256];
	struct i2c_msg msg; //要发送的数据结构体

	/* 寄存器首地址 */
	write_buf[0] = reg;
	/* 将要写入的数据拷贝到数组 write_buf 中 */
	memcpy(&write_buf[1], buf, len);

	msg.addr = client->addr; 			// I2C 从设备在总线上的地址
	msg.flags = 0;					  	// 标记为发送数据
	msg.buf = write_buf;			  	// 要写入的数据缓冲区
	msg.len = len + 1;					// 要写入的数据长度

	// printk(PRINTK_GRADE "i2c write reg = %x  data = %x\n", msg.buf[0], msg.buf[1]);
	/* 执行发送 */
	ret = i2c_transfer(client->adapter, &msg, 1);
	if (ret != 1)
	{
		printk(PRINTK_GRADE "i2c write failed=%d reg=%06x len=%d\n", ret, reg, len);
		return -1;
	}
	return 0;
}

/**
 * @brief 读取 I2C 从设备的寄存器数据
 * 
 * @param client I2C 设备
 * @param reg 要读取的寄存器首地址
 * @param val 要读取的数据缓冲区
 * @param len 要读取的数据长度
 * @return 返回执行的结果
 */
static int i2c_read_regs(struct i2c_client *client, u8 reg, u8 *val, u32 len)
{
	int ret = 0;
	struct i2c_msg msg[2];

	/* msg[0] 是读取从设备寄存器的首地址 */
	msg[0].addr = client->addr; 		// I2C 从设备在总线上的地址
	msg[0].flags = 0;					// 标记为发送数据
	msg[0].buf = &reg;					// 需要读取的寄存器首地址
	msg[0].len = 1;						// reg 的长度

	/* msg[1] 是读取的数据 */
	msg[1].addr = client->addr; 		// I2C 从设备在总线上的地址
	msg[1].flags = I2C_M_RD;			// 标记为读取数据
	msg[1].buf = val;					// 读取数据的保存位置
	msg[1].len = len;				// 要读取的数据长度

	ret = i2c_transfer(client->adapter, msg, 2);
	if (ret != 2)
	{
		printk(PRINTK_GRADE "i2c read failed=%d reg=%06x len=%d\n",ret, reg, len);
		return -1;
	}
	return 0;
}

    注意： I2C 的读写都是通过 i2c_transfer 函数进行完成的

  6. I2C 读写函数的使用

    /**
 * @brief 从 tcs3472x 设备的寄存器中读取 8 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 读取的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_read8(struct tcs3472x_dev *dev, u8 reg, u8 *val)
{
	return i2c_read_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, val, 1);
}

/**
 * @brief 从 tcs3472x 设备的寄存器中读取 16 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 读取的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_read16(struct tcs3472x_dev *dev, u8 reg, u16 *data)
{
	int ret = 0;
	u8 val[2];
	ret = i2c_read_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, val, 2);
	if (ret < 0)
	{
		return -1;
	}

	*data = val[1] << 8 | val[0];
	return ret;
}

/**
 * @brief 向 tcs3472x 设备的寄存器中写入 8 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 写入的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_write8(struct tcs3472x_dev *dev, u8 reg, u8 data)
{
	int ret = 0;
	u8 write_buf = data;
	ret = i2c_write_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, &write_buf, 1);
	return ret;
}

注意：到这里相信对 I2C 的驱动编写就没什么难度了吧，驱动的编写流程也算是完成了，最后在吧设备使用的代码添加进行，I2C 的驱动就算完成了。

四、程序源码

tcs3472x.h

/**
 * @file tcs3472x.h
 *
 */

#ifndef _TCS3472X_H_
#define _TCS3472X_H_


/*********************
 *      INCLUDES
 *********************/
// #include <stdbool.h>
/*********************
 *      DEFINES
 *********************/

#define TCS34725_address          (0x29)    // 设备地址
#define TCS34725_COMMAND_BIT      (0x80)    // 命令字节

/* TCS34725传感器配置寄存器 */
#define TCS34725_ENABLE           (0x00)    // 启用传感器
#define TCS34725_ATIME            (0x01)    // 集成时间
#define TCS34725_WTIME            (0x03)    // R / W 等待时间
#define TCS34725_AILTL            (0x04)    // 清除通道下限中断阈值
#define TCS34725_AILTH            (0x05)
#define TCS34725_AIHTL            (0x06)    // 清除通道上限中断阈值
#define TCS34725_AIHTH            (0x07)    // 配置寄存器
#define TCS34725_PERS             (0x0C)    // 中断永久性过滤器
#define TCS34725_CONFIG           (0x0C)    // 中断永久性过滤器
#define TCS34725_CONTROL          (0x0F)    // 增益倍数
#define TCS34725_ID               (0x12)    // 设备识别号 0x44 = TCS34721/TCS34725, 0x4D = TCS34723/TCS34727
#define TCS34725_STATUS           (0x13)    // 设备状态
#define TCS34725_CDATAL           (0x14)    // 光照强度低字节
#define TCS34725_CDATAH           (0x15)    // 光照强度高字节
#define TCS34725_RDATAL           (0x16)    // 红色数据低字节
#define TCS34725_RDATAH           (0x17)
#define TCS34725_GDATAL           (0x18)    // 绿色数据低字节
#define TCS34725_GDATAH           (0x19)
#define TCS34725_BDATAL           (0x1A)    // 蓝色数据低字节
#define TCS34725_BDATAH           (0x1B)

/* 启动传感器 */
#define TCS34725_ENABLE_AIEN      (0x10)    // RGBC中断使能
#define TCS34725_ENABLE_WEN       (0x08)    // 等待启用：写1激活等待计时器，写0禁用等待计时器
#define TCS34725_ENABLE_AEN       (0x02)    // RGBC启用：写1激活RGBC，写0禁用RGBC
#define TCS34725_ENABLE_PON       (0x01)    // 通电：写入1激活内部振荡器，0禁用内部振荡器

/**********************
 *      TYPEDEFS
 **********************/

/* 集成时间配置参数
 * 最大RGBC计数 = (256 - cycles) × 1024 
 * 集成时间 ≈ (256 - cycles) × 2.4ms */
typedef enum
{
    TCS34725_INTEGRATIONTIME_2_4MS  = 0xFF,   // 2.4ms - 1 cycles   - Max Count: 1024
    TCS34725_INTEGRATIONTIME_24MS   = 0xF6,   // 24ms  - 10 cycles  - Max Count: 10240
    TCS34725_INTEGRATIONTIME_50MS   = 0xEC,   // 50ms  - 20 cycles  - Max Count: 20480
    TCS34725_INTEGRATIONTIME_101MS  = 0xD5,   // 101ms - 42 cycles  - Max Count: 43008
    TCS34725_INTEGRATIONTIME_154MS  = 0xC0,   // 154ms - 64 cycles  - Max Count: 65535
    TCS34725_INTEGRATIONTIME_700MS  = 0x00    // 700ms - 256 cycles - Max Count: 65535
}
tcs34725_integration_time_t;

/* 增益倍数 */
typedef enum
{
    TCS34725_GAIN_1X                = 0x00,   // 1X增益
    TCS34725_GAIN_4X                = 0x01,   // 4X增益
    TCS34725_GAIN_16X               = 0x02,   // 16X增益
    TCS34725_GAIN_60X               = 0x03    // 60X增益
}
tcs34725_gain_multiple_t;

/**********************
 * GLOBAL PROTOTYPES
 **********************/


/**********************
 *      MACROS
 **********************/

#endif /* _TCS3472X_H_ */

i2c_tcs34725_module.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/i2c.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/platform_device.h>

#include "tcs3472x.h"
/***************************************************************
文件名 : i2c_tcs34725_module.c
作者 : jiaozhu
版本 : V1.0
描述 : 颜色传感器 TCS34725 驱动文件。
其他 : 无
日志 : 初版 V1.0 2023/1/4
***************************************************************/

#define PRINTK_GRADE KERN_INFO

/*------------------字符设备内容----------------------*/
#define TCS3472x_NAME "I2C_TCS3472x"
#define TCS3472x_CNT (1)

struct tcs3472x_dev {
	struct i2c_client *client; 			// i2c 设备
	dev_t devid; 						// 设备号
	struct cdev cdev; 					// cdev
	struct class *class; 				// 类
	struct device *device; 				// 设备
	struct device_node *node;			// 设备节点
	u16 colour_r, colour_g, colour_b, colour_c;		// tcs3472x 设备的RGBC数据
};

/**
 * @brief 向 I2C 从设备的寄存器写入数据
 * 
 * @param client I2C 设备
 * @param reg 要写入的寄存器首地址
 * @param val 要写入的数据缓冲区
 * @param len 要写入的数据长度
 * @return 返回执行的结果
 */
static int i2c_write_regs(struct i2c_client *client, u8 reg, u8 *buf, u8 len)
{
	int ret = 0;
	u8 write_buf[256];
	struct i2c_msg msg; //要发送的数据结构体

	/* 寄存器首地址 */
	write_buf[0] = reg;
	/* 将要写入的数据拷贝到数组 write_buf 中 */
	memcpy(&write_buf[1], buf, len);

	msg.addr = client->addr; 			// I2C 从设备在总线上的地址
	msg.flags = 0;					  	// 标记为发送数据
	msg.buf = write_buf;			  	// 要写入的数据缓冲区
	msg.len = len + 1;					// 要写入的数据长度

	// printk(PRINTK_GRADE "i2c write reg = %x  data = %x\n", msg.buf[0], msg.buf[1]);
	/* 执行发送 */
	ret = i2c_transfer(client->adapter, &msg, 1);
	if (ret != 1)
	{
		printk(PRINTK_GRADE "i2c write failed=%d reg=%06x len=%d\n", ret, reg, len);
		return -1;
	}
	return 0;
}

/**
 * @brief 读取 I2C 从设备的寄存器数据
 * 
 * @param client I2C 设备
 * @param reg 要读取的寄存器首地址
 * @param val 要读取的数据缓冲区
 * @param len 要读取的数据长度
 * @return 返回执行的结果
 */
static int i2c_read_regs(struct i2c_client *client, u8 reg, u8 *val, u32 len)
{
	int ret = 0;
	struct i2c_msg msg[2];

	/* msg[0] 是读取从设备寄存器的首地址 */
	msg[0].addr = client->addr; 		// I2C 从设备在总线上的地址
	msg[0].flags = 0;					// 标记为发送数据
	msg[0].buf = &reg;					// 需要读取的寄存器首地址
	msg[0].len = 1;						// reg 的长度

	/* msg[1] 是读取的数据 */
	msg[1].addr = client->addr; 		// I2C 从设备在总线上的地址
	msg[1].flags = I2C_M_RD;			// 标记为读取数据
	msg[1].buf = val;					// 读取数据的保存位置
	msg[1].len = len;				// 要读取的数据长度

	ret = i2c_transfer(client->adapter, msg, 2);
	if (ret != 2)
	{
		printk(PRINTK_GRADE "i2c read failed=%d reg=%06x len=%d\n",ret, reg, len);
		return -1;
	}
	return 0;
}

/**
 * @brief 从 tcs3472x 设备的寄存器中读取 8 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 读取的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_read8(struct tcs3472x_dev *dev, u8 reg, u8 *val)
{
	return i2c_read_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, val, 1);
}

/**
 * @brief 从 tcs3472x 设备的寄存器中读取 16 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 读取的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_read16(struct tcs3472x_dev *dev, u8 reg, u16 *data)
{
	int ret = 0;
	u8 val[2];
	ret = i2c_read_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, val, 2);
	if (ret < 0)
	{
		return -1;
	}

	*data = val[1] << 8 | val[0];
	return ret;
}

/**
 * @brief 向 tcs3472x 设备的寄存器中写入 8 位数据
 * 
 * @param dev tcs3472x 设备
 * @param reg 寄存器地址
 * @param val 写入的值
 * @return 返回执行的结果
 */
static int i2c_tcs3472x_write8(struct tcs3472x_dev *dev, u8 reg, u8 data)
{
	int ret = 0;
	u8 write_buf = data;
	ret = i2c_write_regs((struct i2c_client *)dev->client, TCS34725_COMMAND_BIT | reg, &write_buf, 1);
	return ret;
}

/**
 * @brief 读取 tcs3472x 设备颜色和光照强度数据，注意每次读取时，
 * 需要保证颜色传感器之间有足够的采样时间，集成时间 ≈ (256 - cycles) × 2.4ms
 * 
 * @param dev tcs3472x 设备
 * @return 返回执行的结果
 */
static int tcs3472x_colour_data(struct tcs3472x_dev *dev)
{
	int ret = 0;
	/* 读取 colour_r */
	ret = i2c_tcs3472x_read16(dev, TCS34725_RDATAL, &dev->colour_r);
	if (ret < 0)
	{
		return -1;
	}
	/* 读取 colour_g */
	ret = i2c_tcs3472x_read16(dev, TCS34725_GDATAL, &dev->colour_g);
	if (ret < 0)
	{
		return -1;
	}
	/* 读取 colour_b */
	ret = i2c_tcs3472x_read16(dev, TCS34725_BDATAL, &dev->colour_b);
	if (ret < 0)
	{
		return -1;
	}
	/* 读取 colour_c */
	ret = i2c_tcs3472x_read16(dev, TCS34725_CDATAL, &dev->colour_c);
	if (ret < 0)
	{
		return -1;
	}

	return ret;
}

/**
 * @brief 启动 tcs3472x 
 * 
 * @param dev tcs3472x 设备
 * @return 返回执行的结果
 */
static int tcs3472x_device_start(struct tcs3472x_dev *dev)
{
	int ret = 0;
    u8 read_buf;
	// printk(PRINTK_GRADE "tcs3472x start......\n");

	/* 1. 获取TCS34725型号 */
	ret = i2c_tcs3472x_read8(dev, TCS34725_ID, &read_buf);
	if (ret < 0)
	{
		return -1;
	}
	// printk(PRINTK_GRADE "tcs3472x type is: %x\n", read_buf);

	/* 2. 通过设备识别号判断是否是 tcs3472x类型设备 */
	if ( !((read_buf == 0x44) || (read_buf == 0x4D)) )
    {
        printk(PRINTK_GRADE "The current device is not a tcs3472x device\n");
        return -1;
    }

	/* 3.设置集成时间，默认设置为 2.4ms */
	ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_2_4MS);
	if (ret < 0)
	{
		return -1;
	}

	/* 4.设置增益倍数，默认设置为 60x*/
	ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_60X);
	if (ret < 0)
	{
		return -1;
	}

	/* 5.启用传感器 */
	ret = i2c_tcs3472x_write8(dev, TCS34725_ENABLE, TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN);
	if (ret < 0)
	{
		return -1;
	}

	/* 保证第一次采集时留有充足的时间 */
	// mdelay(10);
	return ret;
}

/**
 * @brief 停止 tcs3472x 
 * 
 * @param dev tcs3472x 设备
 * @return 返回执行的结果
 */
static int tcs3472x_device_stop(struct tcs3472x_dev *dev)
{
	int ret = 0;
	u8 read_buf;
	/* 读取原有状态 */
	ret = i2c_tcs3472x_read8(dev, TCS34725_ENABLE, &read_buf);
	if (ret < 0)
	{
		return -1;
	}
	/* 停止 tcs3472x */
	ret = i2c_tcs3472x_write8(dev, TCS34725_ENABLE, read_buf & ~(TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN));
	if (ret < 0)
	{
		return -1;
	}
	return ret;
}

/**
 * @brief 设置 tcs3472x 集成时间
 * 
 * @param dev tcs3472x 设备
 * @param integration_time 集成时间
 * @return 返回执行的结果
 */
static int tcs3472x_integration_time(struct tcs3472x_dev *dev, tcs34725_integration_time_t integration_time)
{
	int ret = 0;
	switch (integration_time)
	{
		case TCS34725_INTEGRATIONTIME_2_4MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_2_4MS);
			break;

		case TCS34725_INTEGRATIONTIME_24MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_24MS);
			break;

		case TCS34725_INTEGRATIONTIME_50MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_50MS);
			break;

		case TCS34725_INTEGRATIONTIME_101MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_101MS);
			break;

		case TCS34725_INTEGRATIONTIME_154MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_154MS);
			break;

		case TCS34725_INTEGRATIONTIME_700MS:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_700MS);
			break;
		
		default:
			ret = i2c_tcs3472x_write8(dev, TCS34725_ATIME, TCS34725_INTEGRATIONTIME_2_4MS);
			break;
	}
	return ret;
}

/**
 * @brief 设置 tcs3472x 增益倍数
 * 
 * @param dev tcs3472x 设备
 * @param gain_multiple 增益倍数
 * @return 返回执行的结果
 */
static int tcs3472x_gain_multiple(struct tcs3472x_dev *dev, tcs34725_gain_multiple_t gain_multiple)
{
	int ret = 0;
	switch (gain_multiple)
	{
		case TCS34725_GAIN_1X:
			ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_1X);
			break;

		case TCS34725_GAIN_4X:
			ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_4X);
			break;

		case TCS34725_GAIN_16X:
			ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_16X);
			break;

		case TCS34725_GAIN_60X:
			ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_60X);
			break;
		
		default:
			ret = i2c_tcs3472x_write8(dev, TCS34725_CONTROL, TCS34725_GAIN_60X);
			break;
	}
	return ret;
}

/**
 * @brief 打开设备
 * 
 * @param inode 传递给驱动的 inode
 * @param filp 设备文件，file 结构体有个叫做 private_data 的成员变量
 * 一般在 open 的时候将 private_data 指向设备结构体。
 * @return 0 成功;其他 失败
 */
static int tcs3472x_open(struct inode *inode, struct file *filp)
{
	/* 从 file 结构体获取 cdev 指针，再根据 cdev 获取 ap3216c_dev 首地址 */
	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct tcs3472x_dev *tcs_dev = container_of(cdev, struct tcs3472x_dev, cdev);

	printk(PRINTK_GRADE "tcs3472x open\r\n");

    return tcs3472x_device_start(tcs_dev);
}

/**
 * @brief 从设备读取数据
 * 
 * @param filp 要打开的设备文件(文件描述符)
 * @param buf 返回给用户空间的数据缓冲区
 * @param cnt 要读取的数据长度
 * @param offt 相对于文件首地址的偏移
 * @return 0 成功;其他 失败
 */
static ssize_t tcs3472x_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	u16 data[4];
	int ret = 0;
    /* 从 file 结构体获取 cdev 指针，再根据 cdev 获取 ap3216c_dev 首地址 */
	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct tcs3472x_dev *tcs_dev = container_of(cdev, struct tcs3472x_dev, cdev);

    // printk(PRINTK_GRADE "tcs3472x read\r\n");

	ret = tcs3472x_colour_data(tcs_dev);

	// printk(PRINTK_GRADE "R = %d    G = %d    B = %d    C = %d\r\n",
	// 	tcs_dev->colour_r, tcs_dev->colour_g, tcs_dev->colour_b, tcs_dev->colour_c);

	data[0] = tcs_dev->colour_r;
	data[1] = tcs_dev->colour_g;
	data[2] = tcs_dev->colour_b;
	data[3] = tcs_dev->colour_c;
	/* 将数据传递给用户空间 */
	ret = copy_to_user(buf, data, sizeof(data));

    return ret;
}

/**
 * @brief 向设备写数据
 * @param filp 设备文件，表示打开的文件描述符
 * @param buf 要写给设备写入的数据
 * @param cnt 要写入的数据长度
 * @param offt 相对于文件首地址的偏移
 * @return 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t tcs3472x_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
	u8 write_buf[256];
    /* 从 file 结构体获取 cdev 指针，再根据 cdev 获取 ap3216c_dev 首地址 */
	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct tcs3472x_dev *tcs_dev = container_of(cdev, struct tcs3472x_dev, cdev);

	// printk(PRINTK_GRADE "tcs3472x write\r\n");
	if (cnt != 2)
	{
		printk(PRINTK_GRADE "data in wrong format!\r\n");
	}

	/* 接收用户空间传递的数据 */
    ret = copy_from_user(write_buf, buf, cnt);
    if(ret != 0){
		printk(PRINTK_GRADE "kernel recevdata failed!\r\n");
    }

	/* 第一个参数为 1 时，表示设备集成时间 */
	if (write_buf[0] == 1)
	{
		ret = tcs3472x_integration_time(tcs_dev, write_buf[1]);
	}
	/* 第一个参数为 2 时，设置增益倍数 */
	else if (write_buf[0] == 2)
	{
		ret = tcs3472x_gain_multiple(tcs_dev, write_buf[1]);
	}
	else
	{
		printk(PRINTK_GRADE "data in wrong format!\r\n");
		ret = -1;
	}
    
    return ret;
}

/**
 * @brief 关闭/释放设备
 * @param filp 要关闭的设备文件(文件描述符)
 * @return 0 成功;其他 失败
*/
static int tcs3472x_release(struct inode *inode, struct file *filp)
{
	/* 从 file 结构体获取 cdev 指针，再根据 cdev 获取 ap3216c_dev 首地址 */
	struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;
	struct tcs3472x_dev *tcs_dev = container_of(cdev, struct tcs3472x_dev, cdev);

    //printk("chrdevbase release！\r\n");
	printk(PRINTK_GRADE "tcs3472x release\r\n");

	tcs3472x_device_stop(tcs_dev);
    return 0;
}

/* 设备操作函数结构体 */
static struct file_operations tcs3472x_ops = {
    .owner = THIS_MODULE, 
    .open = tcs3472x_open,
    .read = tcs3472x_read,
    .write = tcs3472x_write,
    .release = tcs3472x_release,
};

/**
 * @brief i2c 驱动的 probe 函数，当驱动与设备匹配以后此函数就会执行
 * @param client i2c 设备
 * @param id i2c 设备 ID
 * @return 0，成功;其他负值,失败
*/
static int tcs3472x_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret = -1; 						// 保存错误状态码
	struct tcs3472x_dev *tcs_dev;		// 设备数据结构体  

	/*---------------------注册字符设备驱动-----------------*/
	
	/* 驱动与总线设备匹配成功 */
	printk(KERN_EMERG "\t  %s match successed  \r\n", client->name);

	/* 申请内存并与 client->dev 进行绑定。*/
	/* 在 probe 函数中使用时，当设备驱动被卸载，该内存被自动释放，也可使用 devm_kfree() 函数直接释放 */
	tcs_dev = devm_kzalloc(&client->dev, sizeof(*tcs_dev), GFP_KERNEL);
	if(!tcs_dev)
	{
		pr_err("Failed to request memory \r\n");
		return -ENOMEM;
	}

	/* 1、创建设备号 */
	/* 采用动态分配的方式，获取设备编号，次设备号为0 */
	/* 设备名称为 TCS3472x_NAME，可通过命令 cat /proc/devices 查看 */
	/* TCS3472x_CNT 为1，只申请一个设备编号 */
	ret = alloc_chrdev_region(&tcs_dev->devid, 0, TCS3472x_CNT, TCS3472x_NAME);
	if (ret < 0)
	{
		pr_err("%s Couldn't alloc_chrdev_region, ret = %d \r\n", TCS3472x_NAME, ret);
		return -ENOMEM;
	}

	/* 2、初始化 cdev */
	/* 关联字符设备结构体 cdev 与文件操作结构体 file_operations */
	tcs_dev->cdev.owner = THIS_MODULE;
	cdev_init(&tcs_dev->cdev, &tcs3472x_ops);

	/* 3、添加一个 cdev */
	// 添加设备至cdev_map散列表中
	ret = cdev_add(&tcs_dev->cdev, tcs_dev->devid, TCS3472x_CNT);
	if (ret < 0)
	{
		pr_err("fail to add cdev \r\n");
		goto del_unregister;
	}

	/* 4、创建类 */
	tcs_dev->class = class_create(THIS_MODULE, TCS3472x_NAME);
	if (IS_ERR(tcs_dev->class)) 
	{
		pr_err("Failed to create device class \r\n");
		goto del_cdev;
	}

	/* 5、创建设备,设备名是 TCS3472x_NAME */
	/*创建设备 TCS3472x_NAME 指定设备名，*/
	tcs_dev->device = device_create(tcs_dev->class, NULL, tcs_dev->devid, NULL, TCS3472x_NAME);
	if (IS_ERR(tcs_dev->device)) {
		goto destroy_class;
	}
	tcs_dev->client = client;
	
	/* 保存 ap3216cdev 结构体 */
	i2c_set_clientdata(client, tcs_dev);

	return 0;

destroy_class:
	device_destroy(tcs_dev->class, tcs_dev->devid);
del_cdev:
	cdev_del(&tcs_dev->cdev);
del_unregister:
	unregister_chrdev_region(tcs_dev->devid, TCS3472x_CNT);
	return -EIO;
}

/**
 * @brief i2c 驱动的 remove 函数，移除 i2c 驱动的时候此函数会执行
 * @param client i2c 设备
 * @return 0，成功;其他负值,失败
*/
static int tcs3472x_remove(struct i2c_client *client)
{
	struct tcs3472x_dev *tcs_dev = i2c_get_clientdata(client);

	/*---------------------注销字符设备驱动-----------------*/

	/* 1、删除 cdev */
	cdev_del(&tcs_dev->cdev);
	/* 2、注销设备号 */
	unregister_chrdev_region(tcs_dev->devid, TCS3472x_CNT);
	/* 3、注销设备 */
	device_destroy(tcs_dev->class, tcs_dev->devid);
	/* 4、注销类 */
	class_destroy(tcs_dev->class);
	return 0;
}

/* 传统匹配方式 ID 列表 */
static const struct i2c_device_id gtp_device_id[] = {
	{"colour,tcs34721", 0},
	{"colour,tcs34725", 0},
	{"colour,tcs34723", 0},
	{"colour,tcs34727", 0},
	{}};

/* 设备树匹配表 */
static const struct of_device_id tcs3472x_of_match_table[] = {
	{.compatible = "colour,tcs34721"},
	{.compatible = "colour,tcs34725"},
	{.compatible = "colour,tcs34723"},
	{.compatible = "colour,tcs34727"},
	{/* sentinel */}};

/* i2c总线设备结构体 */
struct i2c_driver tcs3472x_driver = {
	.probe = tcs3472x_probe,
	.remove = tcs3472x_remove,
	.id_table = gtp_device_id,
	.driver = {
		.name = "colour,tcs3472x",
		.owner = THIS_MODULE,
		.of_match_table = tcs3472x_of_match_table,
	},
};

/**
 * @brief 驱动入口函数
 * @return 0，成功;其他负值,失败
*/
static int __init tcs3472x_driver_init(void)
{
	int ret;
	pr_info("tcs3472x_driver_init\n");
	ret = i2c_add_driver(&tcs3472x_driver);
	return ret;
}

/**
 * @brief 驱动出口函数
 * @return 0，成功;其他负值,失败
*/
static void __exit tcs3472x_driver_exit(void)
{
	pr_info("tcs3472x_driver_exit\n");
	i2c_del_driver(&tcs3472x_driver);
}


/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(tcs3472x_driver_init);
module_exit(tcs3472x_driver_exit);

/* LICENSE 和作者信息 */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("JIAOZHU");
MODULE_INFO(intree, "Y");

Makefile

# 模块需要的.o文件
obj-m := i2c_tcs34725_module.o

# linux内核源码和当前路径
KERNELDIR := /home/work/arm_linux/kernel
CURRENT_PATH := $(shell pwd)

# EXTRA_CFLAGS := -I $(CURRENT_PATH)

# 配置编译器
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
CC  = $(CROSS_COMPILE)gcc

# 模块编译目标
all: 
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

五、测试程序

drive_read_app.c

#include "sys/stat.h"
#include <stdio.h> 
#include <linux/types.h> 
#include <stdlib.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/ioctl.h> 
#include <errno.h> 
#include <assert.h> 
#include <string.h> 
#include <linux/i2c.h> 
#include <linux/i2c-dev.h>

#include "tcs3472x.h"
/***************************************************************
文件名 : drive_read_app.c
作者 : jiaozhu
版本 : V1.0
描述 : 驱动读取测试
其他 : 使用方法：./drive_read_app [/dev/xxx]
argv[1] 需要读取的驱动
日志 : 初版 V1.0 2023/1/4
***************************************************************/

/**
* @brief main 主程序
* @param argc argv 数组元素个数
* @param argv 具体参数
* @return 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
    int fd;
    char *filename;
    unsigned short data_buf[4];
    unsigned char write_buf[2];
    int ret = 0;

    if(argc != 2){
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    /* 打开驱动文件 */
    fd = open(filename, O_RDWR);
    if(!fd){
        printf("Can't open file %s\r\n", filename);
        return -1;
    }

    /* 设置集成时间 */
    write_buf[0] = 1;
    write_buf[1] = TCS34725_INTEGRATIONTIME_700MS;
    ret = write(fd, write_buf, 2);
    if(ret < 0){
        printf("Failed to set integration time!\r\n");
    }

    /* 设置增益倍数 */
    write_buf[0] = 2;
    write_buf[1] = TCS34725_GAIN_60X;
    ret = write(fd, write_buf, 2);
    if(ret < 0){
        printf("Failed to set gain multiple!\r\n");
    }

    /* 延时 1s，保证第一次采集时留有充足的时间 */
    sleep(1);

    /* 从驱动文件读取数据 */
    while (1)
    {
        ret = read(fd, data_buf, sizeof(data_buf));
        if (ret == 0)       
        {
            printf("R = %d, G = %d, B = %d, C = %d \r\n", 
                data_buf[0], data_buf[1], data_buf[2], data_buf[3]);
        }
        else
        {
            printf("read file %s failed!\r\n", filename);
        }
        /* 延时 2s */
        usleep(2000000);
    }

    close(fd);

    return 0;
}

六、测试

  1. 加载模块， 命令是 insmod i2c_tcs34725_module.ko

  2. 运行测试 app，命令是 ./drive_read_app /dev/I2C_TCS3472x

  3. 卸载模块，命令是 rmmod i2c_tcs34725_module

到此 TCS34725 的驱动完成了，有不好的地方望各位大佬指出，最后声明一下，此程序只供学习，出现任何问题概不负责。

标签：return,ret,tcs3472x,dev,传感器,Linux,TCS34725,i2c
From： https://www.cnblogs.com/jzcn/p/17032141.html

相关文章

  • 《DFZU2EG_4EV MPSoC之嵌入式Linux开发指南》第五章 Petalinux的安装
    Petalinux的安装​本章将带大家来安装Petalinux开发工具，需要注意的是与Vivado工具不同的是我们不是将petalinux工具安装在Windows系统下，而是安装在Ubuntu操作系统中，所以在此......
  • 《DFZU2EG_4EV MPSoC之嵌入式Linux开发指南》第六章 Petalinux设计流程实战​
    Petalinux设计流程实战​PetaLinux工具提供了在Xilinx处理系统上自定义、构建和部署嵌入式Linux解决方案所需的一切。该解决方案旨在提高设计生产力，可与Xilinx硬件设计工具......
  • 调整Linux系统为正确时区
    一、如何调整Linux系统为正确时区 一、查看当前的时区情况#date#dateFriJan612:52:24EST2023#ll-l/etc/localtimelrwxrwxrwx.1rootroot38Jan506......
  • Arch Linux 为 Discord 设置代理
    复制图标到用户所属目录$cp/usr/share/applications/discord.desktop~/.local/share/applications/修改启动命令为其添加代理[DesktopEntry]Name=DiscordStartup......
  • 在linux上测试net程序
    1、将net程序发布为linux内核，并且自包含框架  2、安装WSL并安装Ubuntu（可参考：https://learn.microsoft.com/zh-cn/windows/wsl/install）。如果安不上就参考《旧版本的......
  • Linux USB设备驱动(二)
    Note: 本文主要列举几个usb设备驱动实例一、“USBLED”驱动模块在前面的实验室中，开发了一个功能齐全的USBHID设备的固件，该设备能够通过使用HID报告发送和接收数据。......
  • (笔记)在每个 Linux 用户SSH登录时执行自定义脚本
     有些时候，我们需要在linux用户登录时执行我们自己编写的脚本，比如登录时给个友好的交互输出提示。为了实现该目的，我们有必要去了解一下linux在用户登录时执行内部shell的......
  • Kali 工具系列【2】在kali linux 上抓取握手包
    1、接入一块外置的无线网卡。2、查看可用的wifi接口，回显结果中有wlan0即代表支持监控模式airmon-ng3、开启无线网卡监控模式airmon-ngstartwlan0 命令执行后网卡接口变为......
  • linux安装sftp
    目录linux安装sftp1、创建用户及用户组2、创建文件夹作为sftp用户的根目录3、修改sshd_config3.1、注释Subsystemsftp/usr/libexec/openssh/sftp-server（若不注释，可以通过......
  • Linux拓展之字段分隔符IFS
    前言内部字符单分隔符（InternalFieldSeparator，IFS）在处理文本数据行时，具有很重要的作用。IFS是一个环境变量，默认值是'\t\n'。不可以用echo$IFS获取它保存的分隔符，......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99