当前位置:   article > 正文

【正点原子Linux连载】 第三十七章 Linux IIO驱动实验 摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南_rk3568 adc iio

rk3568 adc iio

1)实验平台:正点原子ATK-DLRK3568开发板
2)平台购买地址:https://detail.tmall.com/item.htm?id=731866264428
3)全套实验源码+手册+视频下载地址: http://www.openedv.com/docs/boards/xiaoxitongban

第三十七章 Linux IIO驱动实验

工业场合里面也有大量的模拟量和数字量之间的转换,也就是我们常说的ADC和DAC。而且随着手机、物联网、工业物联网和可穿戴设备的爆发,传感器的需求只持续增强。比如手机或者手环里面的加速度计、光传感器、陀螺仪、气压计、磁力计等,这些传感器本质上都是ADC,大家注意查看这些传感器的手册,会发现他们内部都会有个ADC,传感器对外提供IIC或者SPI接口,SOC可以通过IIC或者SPI接口来获取到传感器内部的ADC数值,从而得到想要测量的结果。Linux内核为了管理这些日益增多的ADC类传感器,特地推出了IIO子系统,本章我们就来学习如何使用IIO子系统来编写ADC类传感器驱动。

37.1 IIO子系统简介
IIO全称是Industrial I/O,翻译过来就是工业I/O,大家不要看到“工业”两个字就觉得IIO是只用于工业领域的。大家一般在搜索IIO子系统的时候,会发现大多数讲的都是ADC,这是因为IIO就是为ADC类传感器准备的,当然了DAC也是可以的。大家常用的陀螺仪、加速度计、电压/电流测量芯片、光照传感器、压力传感器等内部都是有个ADC,内部ADC将原始的模拟数据转换为数字量,然后通过其他的通信接口,比如IIC、SPI等传输给SOC。因此,当你使用的传感器本质是ADC或DAC器件的时候,可以优先考虑使用IIO驱动框架。
37.1.1 iio_dev
1、iio_dev结构体
IIO子系统使用结构体iio_dev来描述一个具体IIO设备,此设备结构体定义在include/linux/iio/iio.h文件中,结构体内容如下(有省略):
示例代码37.1.1.1 iio_dev结构体

525 struct iio_dev {
526     int             				id;
527     struct module   				*driver_module;
528 
529     int            	 				modes;
530     int             				currentmode;
531     struct device   				dev;
532 
533     struct iio_event_interface  *event_interface;
534 
535     struct iio_buffer 			*buffer;
536     struct list_head    			buffer_list;
537     int             				scan_bytes;
538     struct mutex         			mlock;
539 
540     const unsigned long 			*available_scan_masks;
541     unsigned            			masklength;
542     const unsigned long 			*active_scan_mask;
543     bool                			scan_timestamp;
544     unsigned            			scan_index_timestamp;
545     struct iio_trigger   			*trig;
546     bool               	 			trig_readonly;
547     struct iio_poll_func			*pollfunc;
548     struct iio_poll_func			*pollfunc_event;
549 
550     struct iio_chan_spec const  	*channels;
551     int             				num_channels;
552 
553     struct list_head  			channel_attr_list;
554     struct attribute_group      	chan_attr_group;
555     const char          			*name;
556     const struct iio_info       	*info;
557     clockid_t           			clock_id;
558     struct mutex         			info_exist_lock;
559     const struct iio_buffer_setup_ops   *setup_ops;
560     struct cdev         			chrdev;
561 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
我们来看一下iio_dev结构体中几个比较重要的成员变量:
  • 1

第529行,modes为设备支持的模式,可选择的模如表37.1.1.1所示:
在这里插入图片描述

表37.1.1.1 模式
第530行,currentmode为当前模式。
第535行,buffer为缓冲区。
第536行,buffer_list为当前匹配的缓冲区列表。
第537行,scan_bytes为捕获到,并且提供给缓冲区的字节数。
第540行,available_scan_masks为可选的扫描位掩码,使用触发缓冲区的时候可以通过设置掩码来确定使能哪些通道,使能以后的通道会将捕获到的数据发送到IIO缓冲区。
第542行,active_scan_mask为缓冲区已经开启的通道掩码。只有这些使能了的通道数据才能被发送到缓冲区。
第543行,scan_timestamp为扫描时间戳,如果使能以后会将捕获时间戳放到缓冲区里面。
第545行,trig为IIO设备当前触发器,当使用缓冲模式的时候。
第547行,pollfunc为一个函数,在接收到的触发器上运行。
第550行,channels为IIO设备通道,为iio_chan_spec结构体类型,稍后会详细讲解IIO通道。
第551行,num_channels为IIO设备的通道数。
第555行,name为IIO设备名字。
第556行,info为iio_info结构体类型,这个结构体里面有很多函数,需要驱动开发人员编写,非常重要!我们从用户空间读取IIO设备内部数据,最终调用的就是iio_info里面的函数。稍后会详细讲解iio_info结构体。
第559行,setup_ops为iio_buffer_setup_ops结构体类型,内容如下:
示例代码37.1.1.2 iio_buffer_setup_ops结构体

474 struct iio_buffer_setup_ops {
475     int (*preenable)(struct iio_dev *); 	/* 缓冲区使能之前调用 */
476     int (*postenable)(struct iio_dev *);	/* 缓冲区使能之后调用 */
477     int (*predisable)(struct iio_dev *);	/* 缓冲区禁用之前调用 */
478     int (*postdisable)(struct iio_dev *);	/* 缓冲区禁用之后调用 */
479     bool (*validate_scan_mask)(struct iio_dev *indio_dev,
480           const unsigned long *scan_mask);	/* 检查扫描掩码是否有效 */
481 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

可以看出iio_buffer_setup_ops里面都是一些回调函数,在使能或禁用缓冲区的时候会调用这些函数。如果未指定的话就默认使用iio_triggered_buffer_setup_ops。
继续回到示例代码37.1.1.1中第560行,chrdev为字符设备,由IIO内核创建。
2、iio_dev申请与释放
在使用之前要先申请iio_dev,申请函数为iio_device_alloc,函数原型如下:
struct iio_dev *iio_device_alloc(int sizeof_priv)
函数参数和返回值含义如下:
sizeof_priv:私有数据内存空间大小,一般我们会将自己定义的设备结构体变量作为iio_dev的私有数据,这样可以直接通过iio_device_alloc函数同时完成iio_dev和设备结构体变量的内存申请。申请成功以后使用iio_priv函数来得到自定义的设备结构体变量首地址。
返回值:如果申请成功就返回iio_dev首地址,如果失败就返回NULL。
一般iio_device_alloc和iio_priv之间的配合使用如下所示:
示例代码37.1.1.3 iio_device_alloc和iio_priv函数的使用

1  struct ap3216c_dev *dev;
2  struct iio_dev *indio_dev;
3  
4  /*  1、申请iio_dev内存 */
5  indio_dev = iio_device_alloc(sizeof(*dev));
6  if (!indio_dev)
7   return -ENOMEM;
8  
9  /* 2、获取设备结构体变量地址 */
10 dev = iio_priv(indio_dev); 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
第1行,ap3216c _dev是自定义的设备结构体。	
第2行,indio_dev是iio_dev结构体变量指针。
第5行,使用iio_device_alloc函数来申请iio_dev,并且一起申请了ap3216c_dev的内存。
第10行,使用iio_priv函数从iio_dev中提取出私有数据,也就是ap3216c_dev这个自定义结构体变量首地址。
  • 1
  • 2
  • 3
  • 4

如果要释放iio_dev,需要使用iio_device_free函数,函数原型如下:
void iio_device_free(struct iio_dev *indio_dev)
函数参数和返回值含义如下:
indio_dev:需要释放的iio_dev。
返回值:无。
也可以使用devm_iio_device_alloc来分配iio_dev,这样就不需要我们手动调用iio_device_free函数完成iio_dev的释放工作。
3、iio_dev注册与注销
前面分配好iio_dev以后就要初始化各种成员变量,初始化完成以后就需要将iio_dev注册到内核中,需要用到iio_device_register函数,函数原型如下:
int iio_device_register(struct iio_dev *indio_dev)
函数参数和返回值含义如下:
indio_dev:需要注册的iio_dev。
返回值:0,成功;其他值,失败。
如果要注销iio_dev使用iio_device_unregister函数,函数原型如下:
void iio_device_unregister(struct iio_dev *indio_dev)
函数参数和返回值含义如下:
indio_dev:需要注销的iio_dev。
返回值:0,成功;其他值,失败。
37.1.2 iio_info
iio_dev有个成员变量:info,为iio_info结构体指针变量,这个是我们在编写IIO驱动的时候需要着重去实现的,因为用户空间对设备的具体操作最终都会反映到iio_info里面。iio_info结构体定义在include/linux/iio/iio.h中,结构体定义如下(有省略):
示例代码37.1.2.1 iio_info结构体

393 struct iio_info {
394     const struct attribute_group    *event_attrs;
395     const struct attribute_group    *attrs;
396 
397     int (*read_raw)(struct iio_dev *indio_dev,
398             struct iio_chan_spec const *chan,
399             int *val,
400             int *val2,
401             long mask);
......
416 
417     int (*write_raw)(struct iio_dev *indio_dev,
418              struct iio_chan_spec const *chan,
419              int val,
420              int val2,
421              long mask);
422 
423     int (*write_raw_get_fmt)(struct iio_dev *indio_dev,
424              struct iio_chan_spec const *chan,
425              long mask);
......
462 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
第395行,attrs是通用的设备属性。	
第397和417行,分别为read_raw和write_raw函数,这两个函数就是最终读写设备内部数据的操作函数,需要程序编写人员去实现的。比如应用读取一个陀螺仪传感器的原始数据,那么最终完成工作的就是read_raw函数,我们需要在read_raw函数里面实现对陀螺仪芯片的读取操作。同理,write_raw是应用程序向陀螺仪芯片写数据,一般用于配置芯片,比如量程、数据速率等。这两个函数的参数都是一样的,我们依次来看一下:
indio_dev:需要读写的IIO设备。
chan:需要读取的通道。
val,val2:对于read_raw函数来说val和val2这两个就是应用程序从内核空间读取到数据,一般就是传感器指定通道值,或者传感器的量程、分辨率等。对于write_raw来说就是应用程序向设备写入的数据。val和val2共同组成具体值,val是整数部分,val2是小数部分。但是val2也是对具体的小数部分扩大N倍后的整数值,因为不能直接从内核向应用程序返回一个小数值。比如现在有个值为1.00236,那么val就是1,vla2理论上来讲是0.00236,但是我们需要对0.00236扩大N倍,使其变为整数,这里我们扩大1000000倍,那么val2就是2360。因此val=1,val2=2360。扩大的倍数我们不能随便设置,而是要使用Linux定义的倍数,Linux内核里面定义的数据扩大倍数,或者说数据组合形式如表37.1.2.1所示:
  • 1
  • 2
  • 3
  • 4
  • 5

组合宏 描述
IIO_VAL_INT 整数值,没有小数。比如5000,那么就是val=5000,不需要设置val2
IIO_VAL_INT_PLUS_MICRO 小数部分扩大1000000倍,比如1.00236,此时val=1,val2=2360。
IIO_VAL_INT_PLUS_NANO 小数部分扩大1000000000倍,同样是1.00236,此时val=1,val2=2360000。
IIO_VAL_INT_PLUS_MICRO_DB dB数据,和IIO_VAL_INT_PLUS_MICRO数据形式一样,只是在后面添加db。
IIO_VAL_INT_MULTIPLE 多个整数值,比如一次要传回6个整数值,那么val和val2就不够用了。此宏主要用于iio_info的read_raw_multi函数。
IIO_VAL_FRACTIONAL 分数值,也就是val/val2。比如val=1,val2=4,那么实际值就是1/4。
IIO_VAL_FRACTIONAL_LOG2 值为val>>val2,也就是val右移val2位。比如val=25600,val2=4,那么真正的值就是25600右移4位,25600>>4=1600.
表37.1.2.1 数据组合表
mask:掩码,用于指定我们读取的是什么数据。
第423行的write_raw_get_fmt用于设置用户空间向内核空间写入的数据格式,write_raw_get_fmt函数决定了wtite_raw函数中val和val2的意义,也就是表37.1.2.1中的组合形式。
37.1.3 iio_chan_spec
IIO的核心就是通道,一个传感器可能有多路数据,比如一个ADC芯片支持8路采集,那么这个ADC就有8个通道
Linux内核使用iio_chan_spec结构体来描述通道,定义在include/linux/iio/iio.h文件中,内容如下:
示例代码37.1.3.1 iio_chan_spec结构体

236 struct iio_chan_spec {
237     enum iio_chan_type 	type;
238     int         			channel;
239     int         			channel2;
240     unsigned long       	address;
241     int         			scan_index;
242     struct {
243         char	sign;
244         u8  	realbits;
245         u8  	storagebits;
246         u8  	shift;
247         u8  	repeat;
248         enum 	iio_endian endianness;
249     } scan_type;
250     long            info_mask_separate;
251     long            info_mask_separate_available;
252     long            info_mask_shared_by_type;
253     long            info_mask_shared_by_type_available;
254     long            info_mask_shared_by_dir;
255     long            info_mask_shared_by_dir_available;
256     long            info_mask_shared_by_all;
257     long            info_mask_shared_by_all_available;
258     const struct 	iio_event_spec *event_spec;
259     unsigned int  	num_event_specs;
260     const struct	iio_chan_spec_ext_info *ext_info;
261     const char   	*extend_name;
262     const char   	*datasheet_name;
263     unsigned      	modified:1;
264     unsigned      	indexed:1;
265     unsigned      	output:1;
266     unsigned     	differential:1;
267 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
来看一下iio_chan_spec结构体中一些比较重要的成员变量:
第237行,type为通道类型, iio_chan_type是一个枚举类型,列举出了可以选择的通道类型,定义在include/uapi/linux/iio/types.h文件里面,内容如下:
  • 1
  • 2

示例代码37.1.3.2 iio_chan_type

14 enum iio_chan_type {
15  	IIO_VOLTAGE,        			/* 电压类型 						*/
16 		IIO_CURRENT,        			/* 电流类型 						*/
17  	IIO_POWER,          			/* 功率类型 						*/
18  	IIO_ACCEL,          			/* 加速度类型 					*/
19  	IIO_ANGL_VEL,       			/* 角度类型(陀螺仪) 				*/
20  	IIO_MAGN,           			/* 电磁类型(磁力计) 				*/
21  	IIO_LIGHT,          			/* 灯光类型 						*/
22  	IIO_INTENSITY,      			/* 强度类型(光强传感器) 			*/
23  	IIO_PROXIMITY,      			/* 接近类型(接近传感器) 			*/
24  	IIO_TEMP,           			/* 温度类型 						*/
25  	IIO_INCLI,          			/* 倾角类型(倾角测量传感器) 		*/
26  	IIO_ROT,            			/* 旋转角度类型 					*/
27  	IIO_ANGL,           			/* 转动角度类型(电机旋转角度测量传感器) */
28  	IIO_TIMESTAMP,      			/* 时间戳类型 					*/
29  	IIO_CAPACITANCE,    			/* 电容类型 						*/
30  	IIO_ALTVOLTAGE,     			/* 频率类型 						*/
31  	IIO_CCT,            			/* 笔者暂时未知的类型 			*/
32  	IIO_PRESSURE,       			/* 压力类型 						*/  
33  	IIO_HUMIDITYRELATIVE,		/* 湿度类型 						*/
34  	IIO_ACTIVITY,       			/* 活动类型(计步传感器) 			*/
35  	IIO_STEPS,          			/* 步数类型 						*/
36  	IIO_ENERGY,         			/* 能量类型(卡路里) 				*/
37  	IIO_DISTANCE,       			/* 距离类型 						*/
38  	IIO_VELOCITY,       			/* 速度类型 						*/
39  	IIO_CONCENTRATION,  			/* 浓度类型 						*/
40  	IIO_RESISTANCE,     			/* 电阻类型 						*/
41  	IIO_PH,             			/* PH类型 						*/
42  	IIO_UVINDEX,        			/* 紫外线类型 					*/
43  	IIO_ELECTRICALCONDUCTIVITY, 	/* 电导率类型  					*/
44  	IIO_COUNT,          			/* 计数类型 						*/
45  	IIO_INDEX,          			/* 笔者暂时未知的类型 			*/
46  	IIO_GRAVITY,        			/* 重力类型 						*/
47  	IIO_POSITIONRELATIVE,		/* 相对位置类型 					*/
48  	IIO_PHASE,          			/* 相位类型 						*/
49 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

从示例代码37.1.3.2可以看出,目前Linux内核支持的传感器类型非常丰富,而且支持类型也会不断的增加。如果是ADC,那就是IIO_VOLTAGE类型。如果是ICM20608这样的多轴传感器,那么就是复合类型了,陀螺仪部分是IIO_ANGL_VEL类型,加速度计部分是IIO_ACCEL类型,温度部分就是IIO_TEMP。
继续来看示例代码37.1.3.1中的iio_chan_spec结构体,第238行,当成员变量indexed为1时候,channel为通道索引。
第239行,当成员变量modified为1的时候,channel2为通道修饰符。Linux内核给出了可用的通道修饰符,定义在include/uapi/linux/iio/types.h文件里面,内容如下(有省略)
示例代码37.1.3.3 iio_modifier

52 enum iio_modifier {
53  	IIO_NO_MOD,
54  	IIO_MOD_X,          	/* X轴 		*/
55 	 	IIO_MOD_Y,          	/* Y轴 		*/
56  	IIO_MOD_Z,          	/* Z轴 		*/
...... 
94  	IIO_MOD_PM10,       	/* PM10 	*/
95  	IIO_MOD_ETHANOL,    	/* 乙醇 	*/
96  	IIO_MOD_H2,         	/* H2 		*/
97 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

通道修饰符主要是影响sysfs下的通道文件名字,后面我们会讲解sysfs下通道文件名字组成形式。
继续回到示例代码37.1.3.1,第240行的address用户可以自定义,但是一般会设置为此通道对应的芯片数据寄存器地址address也可以用作其他功能,自行选择,也可以不使用address,一切以实际情况为准。
第241行,当使用触发缓冲区的时候,scan_index是扫描索引。
第242~249,scan_type是一个结构体,描述了扫描数据在缓冲区中的存储格式。我们依次来看一下scan_type各个成员变量的涵义:
scan_type.sign:如果为‘u’表示数据为无符号类型,为‘s’的话为有符号类型。
scan_type.realbits:数据真实的有效位数,比如很多传感器说的10位ADC,其真实有效数据就是10位。
scan_type.storagebits:存储位数,有效位数+填充位。比如有些传感器ADC是12位的,那么我们存储的话肯定要用到2个字节,也就是16位,这16位就是存储位数。
scan_type.shift:右移位数,也就是存储位数和有效位数不一致的时候,需要右移的位数,这个参数不总是需要,一切以实际芯片的数据手册位数。
scan_type.repeat:实际或存储位的重复数量。
scan_type.endianness:数据的大小端模式,可设置为IIO_CPU、IIO_BE(大端)或IIO_LE(小端)。
第250行,info_mask_separate标记某些属性专属于此通道,include/linux/iio/types.h文件中的iio_chan_info_enum枚举类型描述了可选的属性值,如下所示:
示例代码37.1.3.4 iio_chan_info_enum

34 enum iio_chan_info_enum {
35  	IIO_CHAN_INFO_RAW = 0,
36  	IIO_CHAN_INFO_PROCESSED,
37  	IIO_CHAN_INFO_SCALE,
38  	IIO_CHAN_INFO_OFFSET,
......
57  	IIO_CHAN_INFO_DEBOUNCE_TIME,
58  	IIO_CHAN_INFO_CALIBEMISSIVITY,
59  	IIO_CHAN_INFO_OVERSAMPLING_RATIO,
60 };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

第251行,info_mask_shared_by_type标记导出的信息由相同类型的通道共享。也就是iio_chan_spec.type成员变量相同的通道。
第254行,info_mask_shared_by_dir标记某些导出的信息由相同方向的通道共享。
第256行,info_mask_shared_by_all表设计某些信息所有的通道共享,无论这些通道的类型、方向如何,全部共享。
第263行,modified为1的时候,channel2为通道修饰符。
第264行,indexed为1的时候,channel为通道索引。
第265行,output表示为输出通道。
第266行,differential表示为差分通道。
37.2 实验程序编写
本实验对应的例程路径为:开发板光盘1、程序源码3、Linux驱动例程24_iio_ap3216c。
接下来我们就直接使用IIO驱动框架编写AP3216C驱动,AP3216C驱动核心就是IIC,上一章节我们也讲解了如何在IIC总线上使用regmap。因此本章AP3216驱动底层没啥好讲解的,重点是如何套上IIO的驱动框架,因此关于AP3216C芯片内部寄存器、IIC驱动、regmap等不会做讲解,有什么不懂得可以看前面相应得实验章节。
37.2.1 IIO_AP3216C驱动编写
新建名为“23_iio_ap3216c”的文件夹,然后在23_iio_ap3216c文件夹里面创建vscode工程,工作区命名位“iio_ap3216c”。工程创建好以后新建iio_ap3216c.c和iio_ap3216c.h这两个文件,iio_ap3216c.c为AP3216C的驱动代码,iio_ap3216c.h是AP3216C寄存器头文件。先在iio_ap3216c.h中定义好AP3216C的寄存器,输入如下内容:
示例代码37.2.1 iio_ap3216c.h 文件代码段

1 #ifndef AP3216C_H
2 #define AP3216C_H
3 /***************************************************************
4 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
5 文件名 : iio_ap3216c.h
6 作者 : 正点原子 Linux 团队
7 版本 : V1.0
8 描述 : AP3216C 寄存器地址描述头文件
9 其他 : 无
10 论坛 : www.openedv.com
11 日志 : 初版 V1.0 2021/03/19 正点原子 Linux 团队创建
12 ***************************************************************/
13
14 #define AP3216C_ADDR 0X1E /* AP3216C 器件地址 */
15
16 /* AP3316C 寄存器 */
17 #define AP3216C_SYSTEMCONG 0x00 /* 配置寄存器 */
18 #define AP3216C_INTSTATUS 0X01 /* 中断状态寄存器 */
19 #define AP3216C_INTCLEAR 0X02 /* 中断清除寄存器 */
20 #define AP3216C_IRDATALOW 0x0A /* IR 数据低字节 */
21 #define AP3216C_IRDATAHIGH 0x0B /* IR 数据高字节 */
22 #define AP3216C_ALSDATALOW 0x0C /* ALS 数据低字节 */
23 #define AP3216C_ALSDATAHIGH 0X0D /* ALS 数据高字节 */
24 #define AP3216C_PSDATALOW 0X0E /* PS 数据低字节 */
25 #define AP3216C_PSDATAHIGH 0X0F /* PS 数据高字节 */
26 #define AP3216C_ALSCONFIG	0X10	/* ALS配置寄存器 */
27 #define AP3216C_PSCONFIG	0X20	/* PS配置寄存器 */
28 #define AP3216C_PSLEDCONFIG 0X21	/* LED配置寄存器 */
29 #endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
iio_ap3216c.h就是AP3216C器件寄存器宏定义。然后在iio_ap3216c.c输入如下内容:
  • 1

示例代码37.2.2 iio_ap3216c.c 文件代码段

/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名	: iio_ap3216c.c
作者   	: 正点原子Linux团队
版本   	: V1.0
描述   	: AP3216C IIO驱动程序
其他   	: 无
论坛   	: www.openedv.com
日志    	: 初版 V1.0 2023/08/15 正点原子Linux团队创建
***************************************************************/
1   #include <linux/types.h>
2   #include <linux/kernel.h>
3   #include <linux/delay.h>
4   #include <linux/ide.h>
5   #include <linux/init.h>
6   #include <linux/module.h>
7   #include <linux/errno.h>
8   #include <linux/gpio.h>
9   #include <linux/cdev.h>
10  #include <linux/device.h>
11  #include <linux/of_gpio.h>
12  #include <linux/semaphore.h>
13  #include <linux/timer.h>
14  #include <linux/i2c.h>
15  #include <asm/uaccess.h>
16  #include <asm/io.h>
17  #include <linux/regmap.h>
18  #include <linux/iio/iio.h>
19  #include <linux/iio/sysfs.h>
20  #include <linux/iio/trigger_consumer.h>
21  #include <linux/iio/buffer.h>
22  #include <linux/iio/triggered_buffer.h>
23  #include <linux/unaligned/be_byteshift.h>
24  #include <linux/iio/trigger.h>
25  #include "iio_ap3216c.h"
26 
27  #define AP321C_NAME   "ap3216c"
28 
29  /* 
30   * AP3216C的扫描元素,1路ALS(环境关),1路PS(距离传感器),1路IR
31   */
32  enum inv_ap3216c_scan{
33      AP3216C_ALS,
34      AP3216C_PS,
35      AP3216C_IR,
36  };
37 
38  /* 
39   * ap3216c环境光传感器分辨率,扩大1000000倍,
40   * 量程依次为0~20661,0~5162,0~1291,0~323。单位:lux
41   */
42  static const int als_scale_ap3216c[] = {315000, 78800, 19700, 4900};
43 
44 
45  struct ap3216c_dev{
46      struct i2c_client *client;      /*i2c设备*/
47      struct regmap *regmap;          /*regmap*/
48      struct regmap_config regmap_config;
49      struct mutex lock;
50  };
51 
52  /*
53   * ap3216c通道,1路ALS(环境关),1路PS(距离传感器),1路IR
54   */
55  static const struct iio_chan_spec ap3216c_channels[] = {
56      {
57          /* ALS通道 */
58          .type = IIO_INTENSITY,
59          .modified = 1,
60          .channel2 = IIO_MOD_LIGHT_BOTH,
61          .address = AP3216C_ALSDATALOW,
62          .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 
63              BIT(IIO_CHAN_INFO_SCALE),
64          .scan_index = AP3216C_ALS,
65          .scan_type = {
66                  .sign = 'u',
67                  .realbits = 16,
68                  .storagebits = 16,
69                  .endianness = IIO_LE,
70                   },
71      },
72          /* PS通道 */
73      {
74          .type = IIO_PROXIMITY,
75          .address = AP3216C_PSDATALOW,
76          .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
77          .scan_index = AP3216C_PS,
78          .scan_type = {
79                  .sign = 'u',
80                  .realbits = 10,
81                  .storagebits = 16,
82                  .endianness = IIO_LE,
83                   },
84      },
85          /* IR通道 */
86          {
87          .type = IIO_INTENSITY,
88          .modified = 1,
89          .channel2 = IIO_MOD_LIGHT_IR,
90          .address = AP3216C_IRDATALOW,
91          .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
92          .scan_index = AP3216C_IR,
93          .scan_type = {
94                  .sign = 'u',
95                  .realbits = 16,
96                  .storagebits = 16,
97                  .endianness = IIO_LE,
98                   },
99      },
100
101 };
102
103 /*
104  * 扫描掩码,两种情况,全启动0X111,或者都不启动0X0
105  */
106 static const unsigned long ap3216c_scan_masks[] = {
107     BIT(AP3216C_ALS)|BIT(AP3216C_IR)|BIT(AP3216C_PS),
108     0,
109 };
110
111 /*
112  * @description : 读取ap3216c指定寄存器值,读取一个寄存器
113  * @param - dev:  ap3216c设备
114  * @param - reg:  要读取的寄存器
115  * @return    :   读取到的寄存器值
116  */
117 static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, 
u8 reg)
118 {
119     u8 ret;
120     unsigned int data;
121
122     ret = regmap_read(dev->regmap, reg, &data);
123     return (u8)data;
124 }
125
126 /*
127  * @description : 向ap3216c指定寄存器写入指定的值,写一个寄存器
128  * @param - dev:  ap3216c设备
129  * @param - reg:  要写的寄存器
130  * @param - data: 要写入的值
131  * @return   :    无
132  */
133 static void ap3216c_write_reg(struct ap3216c_dev *dev,u8 reg,u8 data)
134 {
135     regmap_write(dev->regmap,reg,data);
136 }
137
138 /*
139  * @description     : 初始化AP3216C
140  * @param - dev     : 要初始化的ap3216c设备
141  * @return          : 0 成功;其他 失败
142  */
143 static int ap3216c_reginit(struct ap3216c_dev *dev)
144 {
145     /* 初始化AP3216C */
146     ap3216c_write_reg(dev, AP3216C_SYSTEMCONG, 0x04);   /* 复位AP3216C            */
147     mdelay(50);                                         /* AP3216C复位最少10ms  */
148     ap3216c_write_reg(dev,AP3216C_SYSTEMCONG,0x03);     /* 开启ALS、PS+IR        */
149     ap3216c_write_reg(dev,AP3216C_ALSCONFIG,0x00);      /* ALS单次转换触发,量程为0~20661 lux */
150     ap3216c_write_reg(dev,AP3216C_PSLEDCONFIG,0x13);    /* IR LED 1脉冲,驱动电流100%*/
151
152     return 0;
153 }
154
155 /*
156   * @description    : 读取AP3216C传感器数
157   * @param - dev    : ap3216c设备 
158   * @param - reg    : 要读取的通道寄存器首地址。
159   * @param - chann2 : 需要读取的通道,比如ALS,IR。
160   * @param - val    : 保存读取到的值。
161   * @return         : 0,成功;其他值,错误
162   */
163 static int ap3216c_read_alsir_data(struct ap3216c_dev *dev, int reg, int channel2, int *val)
164 {
165     int ret = 0;
166     unsigned char data[2];
167
168     switch(channel2){
169         case IIO_MOD_LIGHT_BOTH:    /* 读取ALS数据 */
170             ret = regmap_bulk_read(dev->regmap, reg, data, 2);
171             *val = ((int)data[1]<<8) | data[0];
172             break;
173         case IIO_MOD_LIGHT_IR:      /* 读取IR数据 */
174             ret = regmap_bulk_read(dev->regmap, reg, data, 2);
175             *val = ((int)data[1]<<2) | (data[0] & 0x03);
176             break;
177         default:
178             ret = -EINVAL;
179             break;
180     }
181
182     if(ret){
183         return -EINVAL;
184     }
185
186     return IIO_VAL_INT;
187 }
188
189 /*
190   * @description    : 设置AP3216C的ALS量程(分辨率)
191   * @param - dev    : ap3216c设备
192   * @param - val    : 量程(分辨率值)。
193   * @param - chann2 : 需要设置的通道。
194   * @return         : 0,成功;其他值,错误
195   */
196 static int ap3216c_write_als_scale(struct ap3216c_dev *dev, 
int channel2, int val)
197 {
198     int ret = 0,i;
199     u8 d;
200
201     switch(channel2){
202         case IIO_MOD_LIGHT_BOTH:    /* 设置ALS分辨率 */
203             for(i = 0; i < ARRAY_SIZE(als_scale_ap3216c); ++i){
204                 if(als_scale_ap3216c[i] == val){
205                     d = (i<<4);
206                   ret = regmap_write(dev->regmap, AP3216C_ALSCONFIG,d);
207                 }
208             }
209             break;
210         default:
211             ret = -EINVAL;
212             break;
213     }
214     return ret;
215 }
216
217 /*
218   * @description    : 读函数,当读取sysfs中的文件的时候最终此函数会执行,
219   *                     :此函数里面会从传感器里面读取各种数据,然后上传给应用。
220   * @param - indio_dev      : iio_dev
221   * @param - chan       : 通道
222   * @param - val            : 读取的值,如果是小数值的话,val是整数部分。
223   * @param - val2           : 读取的值,如果是小数值的话,val2是小数部分。
224   * @return                 : 0,成功;其他值,错误
225   */
226 static int ap3216c_read_raw(struct iio_dev *indio_dev,
227                struct iio_chan_spec const *chan,
228                int *val, int *val2, long mask)
229 {
230     int ret = 0;
231     unsigned char data[2];
232     unsigned char regdata = 0;
233     struct ap3216c_dev *dev = iio_priv(indio_dev);
234
235     switch(mask){
236     case IIO_CHAN_INFO_RAW:             
237         mutex_lock(&dev->lock);         /* 上锁*/
238         switch(chan->type){
239             case IIO_INTENSITY:
240                 ret = ap3216c_read_alsir_data(dev,chan->address,
chan->channel2,val);
241                 break;                  /* 值为val */
242             case IIO_PROXIMITY:
243                 ret = regmap_bulk_read(dev->regmap, chan->address,
 data,2);
244                 *val = ((int)(data[1] & 0x03F) << 4 | (data[0] & 0x0F));
245                 ret = IIO_VAL_INT;
246                 break;                  /* 值为val */
247             default :
248             ret = -EINVAL;
249             break;
250         }
251         mutex_unlock(&dev->lock);       /* 释放锁*/
252         return ret;
253     case IIO_CHAN_INFO_SCALE:
254         
255         switch(chan->type){
256             case IIO_INTENSITY:
257                 mutex_init(&dev->lock);         /* 上锁*/
258     regdata = (ap3216c_read_reg(dev,AP3216C_ALSCONFIG) & 0x30) >> 4;
259                 *val =0;
260                 *val2 = als_scale_ap3216c[regdata];
261                 mutex_unlock(&dev->lock);       /* 释放锁*/
262              return IIO_VAL_INT_PLUS_MICRO;  /* 值为val+val2/1000000 */
263             default :
264                 return -EINVAL;
265         }
266         return ret;
267     
268     default :
269         return -EINVAL;
270     }
271     
272     return ret;
273 }   
274
275 /*
276   * @description    : 写函数,当向sysfs中的文件写数据的时候最终此函数会
277   *                         :执行,一般在此函数里面设置传感器,比如量程等。
278   * @param - indio_dev  : iio_dev
279   * @param - chan       : 通道
280   * @param - val        : 应用程序写入的值,如果是小数值的话,val是整数部分。
281   * @param - val2       : 应用程序写入的值,如果是小数值的话,val2是小数部分。
282   * @return             : 0,成功;其他值,错误
283   */
284 static int ap3216c_write_raw(struct iio_dev *indio_dev,
285                 struct iio_chan_spec const *chan,
286                 int val, int val2, long mask)
287 {
288     int ret = 0;
289     struct ap3216c_dev *dev = iio_priv(indio_dev);
290
291     switch(mask){
292        case IIO_CHAN_INFO_SCALE:
293         switch(chan->type){
294             case IIO_INTENSITY:
295                 mutex_init(&dev->lock);
296                ret = ap3216c_write_als_scale(dev,chan->channel2,val2);
297                 mutex_unlock(&dev->lock);
298                 break;
299             default:
300                 ret = -EINVAL;
301                 break;
302         }
303         default:
304             ret = -EINVAL;
305             break;
306     }
307     return ret;
308 }
309
310 /*
311   * @description    : 用户空间写数据格式,比如我们在用户空间操作sysfs来
312   *                 :设置传感器的分辨率,如果分辨率带小数,那么这个小数传递
313   *                 : 到内核空间应该扩大多少倍,此函数就是用来设置这个的。
314   * @param - indio_dev  : iio_dev
315   * @param - chan           : 通道
316   * @param - mask           : 掩码
317   * @return                 : 0,成功;其他值,错误
318   */
319 static int ap3216c_write_raw_get_fmt(struct iio_dev *indio_dev,
320                  struct iio_chan_spec const *chan, long mask)
321 {
322     switch (mask) {
323     case IIO_CHAN_INFO_SCALE:
324         switch (chan->type) {
325         case IIO_INTENSITY:/* 用户空间写的陀螺仪分辨率数据要乘以1000000 */
326             return IIO_VAL_INT_PLUS_MICRO;
327         default:                
328             return IIO_VAL_INT_PLUS_MICRO;
329         }
330     default:
331         return IIO_VAL_INT_PLUS_MICRO;
332     }
333
334     return -EINVAL;
335 }
336
337 /*
338  * iio_info结构体变量
339  */
340 static const struct iio_info ap3216c_info = {
341     .read_raw       = ap3216c_read_raw,
342     .write_raw      = ap3216c_write_raw,
343     .write_raw_get_fmt = &ap3216c_write_raw_get_fmt,  
344 };
345
346 /*
347   * @description     : i2c驱动的probe函数,当驱动与
348   *                    设备匹配以后此函数就会执行
349   * @param - client  : i2c设备
350   * @param - id      : i2c设备ID
351   * @return          : 0,成功;其他负值,失败
352   */   
353 static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
354 {
355     int ret;
356     struct ap3216c_dev *dev;
357     struct iio_dev *indio_dev;
358
359     /*  1、申请iio_dev内存 */
360     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev));
361     if (!indio_dev)
362         return -ENOMEM;
363
364     /* 2、获取ap3216c_dev结构体地址 */
365     dev = iio_priv(indio_dev); 
366     dev->client = client;
367
368     i2c_set_clientdata(client,indio_dev);   /* 保存ap3216cdev结构体 */
369
370     /* 初始化regmap_config设置 */
371     dev->regmap_config.reg_bits = 8;        /* 寄存器长度8bit */
372     dev->regmap_config.val_bits = 8;        /* 值长度8bit */
373
374     /* 初始化IIC接口的regmap */
375     dev->regmap = regmap_init_i2c(client, &dev->regmap_config);
376     if(IS_ERR(dev->regmap)){
377         ret = PTR_ERR(dev->regmap);
378         goto err_regmap_init;
379     }
380
381     mutex_init(&dev->lock);
382
383     /* 4、iio_dev的其他成员变量 */
384     indio_dev->dev.parent = &client->dev;
385     indio_dev->info = &ap3216c_info;
386     indio_dev->name = AP321C_NAME;
387     indio_dev->modes = INDIO_DIRECT_MODE; /* 直接模式,提供sysfs接口 */
388     indio_dev->channels = ap3216c_channels;
389     indio_dev->num_channels = ARRAY_SIZE(ap3216c_channels);
390     indio_dev->available_scan_masks = ap3216c_scan_masks;
391
392     /* 5、注册iio_dev */
393     ret = iio_device_register(indio_dev);
394     if(ret < 0){
395         dev_err(&client->dev, "iio_device_register failed\n");
396         goto err_iio_register;
397     }
398
399     ap3216c_reginit(dev); /* 初始化ap3216c */
400     return 0;
401
402 err_iio_register:
403 err_regmap_init:
404     iio_device_unregister(indio_dev);
405     return ret;
406 }
407
408 /*
409  * @description     : i2c驱动的remove函数,移除i2c驱动的时候此函数会执行
410  * @param - client  : i2c设备
411  * @return          : 0,成功;其他负值,失败
412  */
413 static int ap3216c_remove(struct i2c_client *client)
414 {
415     struct iio_dev *indio_dev = i2c_get_clientdata(client);
416     struct ap3216c_dev *dev;
417
418     dev =iio_priv(indio_dev);
419
420     /* 1、释放regmap */
421     regmap_exit(dev->regmap);
422     /* 2、注销IIO */   
423     iio_device_unregister(indio_dev);
424     return 0;
425 }
426
427 /* 传统匹配方式ID列表 */
428
429 static const struct i2c_device_id ap3216c_id[] = {
430     {"alientek,ap3216c", 0},
431     {}
432 };
433
434 /* 设备树匹配列表 */
435 static const struct of_device_id ap3216c_of_match[] = {
436     { .compatible = "alientek,ap3216c" },
437     { /* Sentinel */ }
438 };
439
440 /* I2C
441 驱动结构体 */
442 static struct i2c_driver ap3216c_driver = {
443     .probe = ap3216c_probe,
444     .remove = ap3216c_remove,
445     .driver = {
446             .owner = THIS_MODULE,
447             .name = "ap3216c",
448             .of_match_table = ap3216c_of_match,
449            },
450     .id_table = ap3216c_id,
451 };
452
453 /*
454  * @description     : 驱动入口函数
455  * @param           : 无
456  * @return          : 无
457  */
458 static int __init ap3216c_init(void)
459 {
460     int ret = 0;
461     ret = i2c_add_driver(&ap3216c_driver);
462     return ret;
463 }
464
465 /*
466  * @description     : 驱动出口函数
467  * @param           : 无
468  * @return          : 无
469  */
470 static void __exit ap3216c_exit(void)
471 {
472     i2c_del_driver(&ap3216c_driver);
473 }
474
475 module_init(ap3216c_init);
476 module_exit(ap3216c_exit);
477 MODULE_LICENSE("GPL");
478 MODULE_AUTHOR("ALIENTEK");
479 MODULE_INFO(intree, "Y");
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447
  • 448
  • 449
  • 450
  • 451
  • 452
  • 453
  • 454
  • 455
  • 456
  • 457
  • 458
  • 459
  • 460
  • 461
  • 462
  • 463
  • 464
  • 465
  • 466
  • 467
  • 468
  • 469
  • 470
  • 471
  • 472
  • 473
  • 474
  • 475
  • 476
  • 477
  • 478
  • 479
  • 480
  • 481
  • 482
  • 483
  • 484
  • 485
  • 486
  • 487
  • 488
  • 489
  • 490
  • 491
  • 492
  • 493

第32~36行,自定义了扫描索引枚举类型inv_ap3216c_scan,包括1路环境光强度,1路接触距离,1路红外光强度。
第45~50行,设备结构体,由于采用了regmap和IIO框架,因此AP3216C的设备结构体非常简单。
第55~101行,AP3216C通道,这里定义了3个通道,分别是:ALS(环境光强度)通道,PS(接触距离)通道,IR(红外光强度)通道。ALS通道有两个属性,IIO_CHAN_INFO_RAW为ALS通道的原始值,IIO_CHAN_INFO_SCANLE是AP3216C的比例,也就是一个单位的原始值为多少光强度,这个需要查阅AP3216C的数据手册。从这里可以看出,想要得到AP3216C的具体光强度,需要两个数据:原始值和比例值,也就是应用程序需要能够从IIO驱动框架中的到着三个值,一般是应用程序读取相应的文件,所以这里就要有三个独立的文件分别表示原始值和比例值,这就是两个属性的来源。剩下的PS通道和IR通道也是同样的道理。
第117~136行,就是上一章的regmap的内容,使用regmap_read来完成对一个寄存器读取操作,使用regmap_write函数来完成对一个寄存器写操作。
第226~273行,这部分就是iio_info,ap3216c_read_raw为读取函数,应用程序读取相应文件的时候此函数执行,ap3216c_write_raw为写函数,应用程序向相应的文件写数据的时候此函数执行。ap3216c_write_raw_get_fmt函数用来设置应用程序向驱动写入的数据格式,ap3216c_info就是具体的iio_info变量,初始化iio_dev的时候需要用到。
第362~415行,ap3216c_probe函数,一般在此函数里面申请iio_dev、初始化并注册,初始化regmap等。
这里就简单的分析了IIO的框架,接下来就是编写APP。
37.3 测试应用程序编写
37.3.1 Linux文件流读取
前面我们都是直接使用cat命令读取对应文件的内容,如果要连续不断的读取传感器数据就不能用cat命令了,我们需要编写对应的APP软件,在编写APP之前我们先了解一下所要用到的API函数。
首先我们要知道,前面使用cat命令读取到的文件内容字符串,虽然看起来像是数字。比如我们使用cat命令读取到的in_intensity_both_scale如图37.3.1.1所示:
在这里插入图片描述

图37.3.1.1 in_intensity_both_scale 文件内容
图37.3.1中的文件内容为0.315000,但是这里的0.315000是字符串,并不是具体的数字,所以我们需要将其转换为对应的数字。另外in_intensity_both_scale是流文件,也叫做标准的I/O流,因此打开、读写操作要使用文件流操作函数。
1、打开文件流
打开文件流使用fopen函数,函数原型如下:
FILE *fopen(const char *pathname, const char *mode)
函数参数和返回值含义如下:
pathname:需要打开的文件流路径。
mode:打开方式,可选的打开方式如表37.3.1.2所示:
mode 描述
r 打开只读文件。
r+ 打开读写文件。
w 打开只写文件,如文件存在则文件长度清零,如文件不存在就自动创建,文件流指针调整到文件头部。
w+ 打开可读写文件,如文件存在则文件长度清零,如文件不存在就自动创建,文件流指针调整到文件头部。
a 以追加的方式打开只写文件,如果文件不存在就新建文件,如果存在就将数据追加到文件末尾。
a+ 以追加的方式打开读写文件,如果文件不存在就新建文件,如果存在就将数据追加到文件末尾。
表37.3.1.2 打开方式
返回值:NULL,打开错误;其他值,打开成功的文件流指针,为FILE类型。
2、关闭文件流
关闭文件流使用函数fclose,函数原型如下:
int fclose(FILE *stream)
函数参数和返回值含义如下:
stream:要关闭的文件流指针。
返回值:0,关闭成功;EOF,关闭错误。
3、读取文件流
要读取文件流使用fread函数,函数原型如下:
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
fread函数用于从给定的输入流中读取最多nmemb个对象到数组ptr中,函数参数和返回值含义如下:
ptr:要读取的数组中首个对象的指针。
size:每个对象的大小。
nmemb:要读取的对象个数。
stream:要读取的文件流。
返回值:返回读取成功的对象个数,如果出现错误或到文件末尾,那么返回一个短计数值(或者0)。
4、写文件流
要向文件流写入数据,使用fwrite函数,函数原型如下:
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
fwrite函数用于向给定的文件流中写入最多nmemb个对象,函数参数和返回值含义如下:
ptr:要写入的数组中首个对象的指针。
size:每个对象的大小。
nmemb:要写入的对象个数。
stream:要写入的文件流。
返回值:返回成功写入的对象个数,如果出现错误或到文件末尾,那么返回一个短计数值(或者0)。
5、格式化输入文件流
fscanf函数用于从一个文件流中格式化读取数据,fscanf函数在遇到空格和换行符的时候就会结束。前面我们说了IIO框架下的sysfs文件内容都是字符串,比如in_accel_scale文件内容为“0.000488281”,这是一串字符串,并不是具体的数字,因此我们在读取的时候就需要使用字符串读取格式。在这里就可以使用fscanf函数来格式化读取文件内容,函数原型如下:
int fscanf(FILE *stream, const char *format, ,[argument…])
fscanf用法和scanf类似,函数参数和返回值含义如下:
stream:要操作的文件流。
format:格式。
argument:保存读取到的数据。
返回值:成功读取到的数据个数,如果读到文件末尾或者读取错误就返回EOF。
37.3.2 编写测试APP
新建名为iio_ap3216App.c的文件,输入如下内容:
示例代码37.3.2.1 iio_ap3216cAPP.c 文件代码段

/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名	: iio_ap3216cAPP.c
作者   	: 正点原子Linux团队
版本   	: V1.0
描述   	: AP3216C设备IIO框架测试程序
其他   	: 无
论坛   	: www.openedv.com
日志    	: 初版 V1.0 2023/08/15 正点原子Linux团队创建
***************************************************************/
1   #include "stdio.h"
2   #include "unistd.h"
3   #include "sys/types.h"
4   #include "sys/stat.h"
5   #include "sys/ioctl.h"
6   #include "fcntl.h"
7   #include "stdlib.h"
8   #include "string.h"
9   #include <poll.h>
10  #include <sys/select.h>
11  #include <sys/time.h>
12  #include <signal.h>
13  #include <fcntl.h>
14  #include <errno.h>
15 
16  /* 字符串转数字,将浮点小数字符串转换为浮点数数值 */
17  #define SENSOR_FLOAT_DATA_GET(ret, index, str, member)\
18      ret = file_data_read(file_path[index], str);\
19      dev->member = atof(str);\
20      
21  /* 字符串转数字,将整数字符串转换为整数数值 */
22  #define SENSOR_INT_DATA_GET(ret, index, str, member)\
23      ret = file_data_read(file_path[index], str);\
24      dev->member = atoi(str);\
25 
26 
27  /* ap3216c iio框架对应的文件路径 */
28  static char *file_path[] = {
29      "/sys/bus/iio/devices/iio:device1/in_intensity_both_scale",
30      "/sys/bus/iio/devices/iio:device1/in_intensity_both_raw",
31      "/sys/bus/iio/devices/iio:device1/in_intensity_ir_raw",
32      "/sys/bus/iio/devices/iio:device1/in_proximity_raw",
33  };
34 
35  /* 文件路径索引,要和file_path里面的文件顺序对应 */
36  enum path_index {
37      IN_INTENSITY_BOTH_SCALE = 0,
38      IN_INTENSITY_BOTH_RAW,
39      IN_INTENSITY_IR_RAW,
40      IN_PROXIMITY_RAW,
41  };
42 
43  /*
44   * ap3216c数据设备结构体
45   */
46  struct ap3216c_dev{
47      int als_raw, ir_raw, ps_raw;
48      float als_scale;
49      float als_act;
50  };
51 
52  struct ap3216c_dev ap3216c;
53 
54   /*
55   * @description         : 读取指定文件内容
56   * @param - filename    : 要读取的文件路径
57   * @param - str         : 读取到的文件字符串
58   * @return              : 0 成功;其他 失败
59   */
60  static int file_data_read(char *filename, char *str)
61  {
62      int ret = 0;
63      FILE *data_stream;
64 
65      data_stream = fopen(filename, "r"); /* 只读打开 */
66      if(data_stream == NULL) {
67          printf("can't open file %s\r\n", filename);
68          return -1;
69      }
70 
71      ret = fscanf(data_stream, "%s", str);
72      if(!ret) {
73          printf("file read error!\r\n");
74      } else if(ret == EOF) {
75          /* 读到文件末尾的话将文件指针重新调整到文件头 */
76          fseek(data_stream, 0, SEEK_SET);  
77      }
78      fclose(data_stream);    /* 关闭文件 */  
79      return 0;
80  }
81 
82   /*
83   * @description : 获取AP3216C数据
84   * @param - dev : 设备结构体
85   * @return      : 0 成功;其他 失败
86   */
87  static int sensor_read(struct ap3216c_dev *dev)
88  {
89      int ret = 0;
90      char str[50];
91 
92      SENSOR_FLOAT_DATA_GET(ret, IN_INTENSITY_BOTH_SCALE, str,
 als_scale);
93      SENSOR_INT_DATA_GET(ret, IN_INTENSITY_BOTH_RAW, str, als_raw);
94      SENSOR_INT_DATA_GET(ret, IN_INTENSITY_IR_RAW, str, ir_raw);
95      SENSOR_INT_DATA_GET(ret, IN_PROXIMITY_RAW, str, ps_raw);
96 
97      /* 将ALS转换为实际lux */
98      dev->als_act = dev->als_scale * dev->als_raw;
99      return ret;
100 }
101
102 /*
103  * @description     : main主程序
104  * @param - argc    : argv数组元素个数
105  * @param - argv    : 具体参数
106  * @return          : 0 成功;其他 失败
107  */
108 int main(int argc, char *argv[])
109 {
110     int ret = 0;
111
112     if (argc != 1) {
113         printf("Error Usage!\r\n");
114         return -1;
115     }
116
117     while (1) {
118         ret = sensor_read(&ap3216c);
119         if(ret == 0) {          /* 数据读取成功 */
120             printf("\r\n原始值:\r\n");
121             printf("als = %d, ps = %d, ir = %d\r\n", ap3216c.als_raw, 
ap3216c.ps_raw, ap3216c.ir_raw);
122             printf("实际值:");
123             printf("act als = %.2f lx\r\n", ap3216c.als_act);
124         }
125         usleep(100000); /*100ms */
126     }
127     return 0;
128 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140

第17~19行,SENSOR_FLOAT_DATA_GET宏用来读取指定路径的文件内容,然后将读到的浮点型字符串数据转换为具体的浮点数据。
第21~24行,SENSOR_INT_DATA_GET宏用来读取指定路径的文件内容,然后将读到的整数型字符串数据转换为具体的整数数据。
第28~33行,需要操作的文件路径。
第36~41行,文件路径索引,要和file_path里面的文件顺序对应。
第60~80行,file_data_read函数用于读取指定文件,第一个参数filename是要读取的文件路径,第二个参数str为读取到的文件内容,为字符串类型。第64行fopen函数打开指定的文件流,第71行调用fscanf函数进行格式化读取,也就是按照字符串方式读取文件,文件内容保存到str参数里面。
第87~100行,sensor_read函数用于读取AP3216C传感器数据,包括光强度、接触距离、红外线强度的原始值,最后将获取到的原始值转换为具体的数值。
第108~126行,main函数,在while循环中调用sensor_read函数读取AP3216C数据,并将读到的数据打印出来。
37.4运行测试
37.4.1 编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件,本章实验的Makefile文件前面的实验基本一样,只是将obj-m变量的值改为“iio_ap3216c.o”,Makefile内容如下所示:
示例代码28.7.1.1 Makefile文件

1  KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
...... 
4  obj-m := iio_ap3216c.o
......
11 clean:
12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
第4行,设置obj-m变量的值为“iio_ap3216c.o”。
  • 1

输入如下命令编译出驱动模块文件:
make ARCH=arm64 //ARCH=arm64必须指定,否则编译会失败
编译成功以后就会生成一个名为“iio_ap3216c.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译iio_ap3216cApp.c这个测试程序:
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc iio_ap3216cApp.c -o iio_App
编译成功以后就会生成iio_App这个应用程序。
37.4.2 运行测试
在Ubuntu中将上一小节编译出来的iio_ap3216c.ko和iio_App通过adb命令发送到开发板的/lib/modules/4.19.232目录下,命令如下:
adb push iio_ap3216c.ko iio_App /lib/modules/4.19.232
加载驱动。
depmod //第一次加载驱动的时候需要运行此命令
modprobe iio_app3216c //加载驱动模块
当驱动模块加载成功以后使用iio_App来测试,输入如下命令:
./ iio_App
测试APP会不断的从AP3216C中读取数据,然后输出到终端上,如图37.4.2.1所示:
在这里插入图片描述

图37.4.2.1 获取到的AP3216C数据
大家可以用手电筒照一下AP3216C,或者手指靠近AP3216C来观察传感器数据有没有变化。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/weixin_40725706/article/detail/664404
推荐阅读
相关标签
  

闽ICP备14008679号