devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于IMX6ULL的AP3216C的QT动态数据曲线图显示_百问网imx6ull 显示传感器状态和动态曲线“”

作者：2023面试高手 | 2024-04-08 12:41:58

赞

踩

百问网imx6ull 显示传感器状态和动态曲线“”

前言：本文为手把手教学 Linux+QT 的典型基础项目 AP3216C 的数据折线图显示，项目使用正点原子的 IMX6ULL 阿尔法( Cortex-A7 系列)开发板。项目需要实现 AP3216C 在 Linux 系统下的驱动，使用 QT 设计 AP3216C 的数据显示页面作为项目的应用层。该项目属于非常简单的入门级项目，核心目的是帮助大家熟悉 Linux 系统下的项目制作和工程研发过程。希望该项目可以帮助大家学会灵活使用 Linux 系统下的传感器开发！（文末有代码开源！）

硬件实物图：

效果图：

本项目核心是教学 Linux+QT 的工程研发流程，如果专注于应用层工程学习的，可以直接使用正点原子提供的 Linux 镜像文件。本教程是适配正点提供的系统镜像的，可以直接使用！

一、AP3216C概述

I.MX6U-ALPHA 开发板上通过 I2C1 连接了一个三合一环境传感器：AP3216C，AP3216C 是由敦南科技推出的一款传感器，其支持环境光强度(ALS)、接近距离(PS)和红外线强度(IR)这三个环境参数检测。该芯片可以通过 IIC 接口与主控制相连，并且支持中断，AP3216C 的特点如下：

①、I2C 接口，快速模式下波特率可以到 400Kbit/S
②、多种工作模式选择：ALS、PS+IR、ALS+PS+IR、PD 等等。
③、内建温度补偿电路。
④、宽工作温度范围(-30°C ~ +80°C)。
⑤、超小封装，4.1mm x 2.4mm x 1.35mm
⑥、环境光传感器具有 16 位分辨率。
⑦、接近传感器和红外传感器具有 10 位分辨率。

这个芯片设计的用途是给手机之类的使用，比如：返回当前环境光强以便调整屏幕亮度；用户接听电话时，将手机放置在耳边后，自动关闭屏幕避免用户误触碰 。

二、基于Linux的AP3216C驱动

2.1 AP3216C的设备树

Linux 内核也将 I2C 驱动分为两部分：

①、I2C 总线驱动，I2C 总线驱动就是 SOC 的 I2C 控制器驱动，也叫做 I2C 适配器驱动。
②、I2C 设备驱动，I2C 设备驱动就是针对具体的 I2C 设备而编写的驱动。

2.1.1 IO修改或添加

需要设置 UART4_TXD 和 UART4_RXD 这两个 IO，NXP 其实已经将他这两个 IO 设置好了，打开 imx6ull-alientek-emmc.dts，然后找到如下内容：

  1. 		pinctrl_i2c1: i2c1grp {
  2. 			fsl,pins = <
  3. 				MX6UL_PAD_UART4_TX_DATA__I2C1_SCL 0x4001b8b0
  4. 				MX6UL_PAD_UART4_RX_DATA__I2C1_SDA 0x4001b8b0 
  5. 			>;
  6. 		};

pinctrl_i2c1 就是 I2C1 的 IO 节点，这里将 UART4_TXD 和 UART4_RXD 这两个 IO 分别复用为 I2C1_SCL 和 I2C1_SDA，电气属性都设置为 0x4001b8b0。 

2.1.2 在 i2c1 节点追加 ap3216c 子节点

AP3216C 是连接到 I2C1 上的，因此需要在 i2c1 节点下添加 ap3216c 的设备子节点，在 imx6ull-alientek-emmc.dts 文件中找到 i2c1 节点

  1. &i2c1 {
  2. 	clock-frequency = <100000>;			/* 时钟频率 */
  3. 	pinctrl-names = "default";
  4. 	pinctrl-0 = <&pinctrl_i2c1>;		/* pinctrl引脚电气属性 */
  5. 	status = "okay";
  6.  
  7. 	ap3216c@1e {
  8. 		compatible = "alientek,ap3216c";
  9. 		reg = <0x1e>;
  10. 	};
  11. };

编译设备树，传到开发板上，重启。此时我们系统的I2C设备有：

2.2 AP3216C 驱动编写

下面编写 AP3216 驱动：

ap3216creg.h：

  1. #ifndef AP3216C_H
  2. #define AP3216C_H
  3. /***************************************************************
  4. 文件名  : ap3216creg.h
  5. 描述     : AP3216C寄存器地址描述头文件
  6. ***************************************************************/
  7. #define AP3216C_ADDR     0X1E /* AP3216C器件地址  */
  8. /* AP3316C寄存器 */
  9. #define AP3216C_SYSTEMCONG 0x00 /* 配置寄存器       */
  10. #define AP3216C_INTSTATUS 0X01 /* 中断状态寄存器   */
  11. #define AP3216C_INTCLEAR 0X02 /* 中断清除寄存器   */
  12. #define AP3216C_IRDATALOW 0x0A /* IR数据低字节     */
  13. #define AP3216C_IRDATAHIGH 0x0B /* IR数据高字节     */
  14. #define AP3216C_ALSDATALOW 0x0C /* ALS数据低字节    */
  15. #define AP3216C_ALSDATAHIGH 0X0D /* ALS数据高字节    */
  16. #define AP3216C_PSDATALOW 0X0E /* PS数据低字节     */
  17. #define AP3216C_PSDATAHIGH 0X0F /* PS数据高字节     */
  18. #endif

ap3216.c：

  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/mach/map.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/io.h>
  18. #include "ap3216creg.h"
  19.  
  20. #define AP3216C_CNT	1
  21. #define AP3216C_NAME	"ap3216c"
  22.  
  23. struct ap3216c_dev {
  24. 	dev_t devid;			/* 设备号 	 */
  25. 	struct cdev cdev;		/* cdev 	*/
  26. 	struct class *class;	/* 类 		*/
  27. 	struct device *device;	/* 设备 	 */
  28. 	struct device_node	*nd; /* 设备节点 */
  29. 	int major;			/* 主设备号 */
  30. 	void *private_data;	/* 私有数据 */
  31. 	unsigned short ir, als, ps;		/* 三个光传感器数据 */
  32. };
  33.  
  34. static struct ap3216c_dev ap3216cdev;
  35.  
  36. /*
  37.  * @description	: 从ap3216c读取多个寄存器数据
  38.  * @param - dev:  ap3216c设备
  39.  * @param - reg:  要读取的寄存器首地址
  40.  * @param - val:  读取到的数据
  41.  * @param - len:  要读取的数据长度
  42.  * @return 		: 操作结果
  43.  */
  44. static int ap3216c_read_regs(struct ap3216c_dev *dev, u8 reg, void *val, int len)
  45. {
  46. 	int ret;
  47. 	struct i2c_msg msg[2];
  48. 	struct i2c_client *client = (struct i2c_client *)dev->private_data;
  49.  
  50. 	/* msg[0]为发送要读取的首地址 */
  51. 	msg[0].addr = client->addr;			/* ap3216c地址 */
  52. 	msg[0].flags = 0;					/* 标记为发送数据 */
  53. 	msg[0].buf = &reg;					/* 读取的首地址 */
  54. 	msg[0].len = 1;						/* reg长度*/
  55.  
  56. 	/* msg[1]读取数据 */
  57. 	msg[1].addr = client->addr;			/* ap3216c地址 */
  58. 	msg[1].flags = I2C_M_RD;			/* 标记为读取数据*/
  59. 	msg[1].buf = val;					/* 读取数据缓冲区 */
  60. 	msg[1].len = len;					/* 要读取的数据长度*/
  61.  
  62. 	ret = i2c_transfer(client->adapter, msg, 2);
  63. 	if(ret == 2) {
  64. 		ret = 0;
  65. 	} else {
  66. 		printk("i2c rd failed=%d reg=%06x len=%d\n",ret, reg, len);
  67. 		ret = -EREMOTEIO;
  68. 	}
  69. 	return ret;
  70. }
  71.  
  72. /*
  73.  * @description	: 向ap3216c多个寄存器写入数据
  74.  * @param - dev:  ap3216c设备
  75.  * @param - reg:  要写入的寄存器首地址
  76.  * @param - val:  要写入的数据缓冲区
  77.  * @param - len:  要写入的数据长度
  78.  * @return 	  :   操作结果
  79.  */
  80. static s32 ap3216c_write_regs(struct ap3216c_dev *dev, u8 reg, u8 *buf, u8 len)
  81. {
  82. 	u8 b[256];
  83. 	struct i2c_msg msg;
  84. 	struct i2c_client *client = (struct i2c_client *)dev->private_data;
  85. 	
  86. 	b[0] = reg;					/* 寄存器首地址 */
  87. 	memcpy(&b[1],buf,len);		/* 将要写入的数据拷贝到数组b里面 */
  88. 		
  89. 	msg.addr = client->addr;	/* ap3216c地址 */
  90. 	msg.flags = 0;				/* 标记为写数据 */
  91.  
  92. 	msg.buf = b;				/* 要写入的数据缓冲区 */
  93. 	msg.len = len + 1;			/* 要写入的数据长度 */
  94.  
  95. 	return i2c_transfer(client->adapter, &msg, 1);
  96. }
  97.  
  98. /*
  99.  * @description	: 读取ap3216c指定寄存器值，读取一个寄存器
  100.  * @param - dev:  ap3216c设备
  101.  * @param - reg:  要读取的寄存器
  102.  * @return 	  :   读取到的寄存器值
  103.  */
  104. static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
  105. {
  106. 	u8 data = 0;
  107.  
  108. 	ap3216c_read_regs(dev, reg, &data, 1);
  109. 	return data;
  110.  
  111. #if 0
  112. 	struct i2c_client *client = (struct i2c_client *)dev->private_data;
  113. 	return i2c_smbus_read_byte_data(client, reg);
  114. #endif
  115. }
  116.  
  117. /*
  118.  * @description	: 向ap3216c指定寄存器写入指定的值，写一个寄存器
  119.  * @param - dev:  ap3216c设备
  120.  * @param - reg:  要写的寄存器
  121.  * @param - data: 要写入的值
  122.  * @return   :    无
  123.  */
  124. static void ap3216c_write_reg(struct ap3216c_dev *dev, u8 reg, u8 data)
  125. {
  126. 	u8 buf = 0;
  127. 	buf = data;
  128. 	ap3216c_write_regs(dev, reg, &buf, 1);
  129. }
  130.  
  131. /*
  132.  * @description	: 读取AP3216C的数据，读取原始数据，包括ALS,PS和IR, 注意！
  133.  *				: 如果同时打开ALS,IR+PS的话两次数据读取的时间间隔要大于112.5ms
  134.  * @param - ir	: ir数据
  135.  * @param - ps 	: ps数据
  136.  * @param - ps 	: als数据 
  137.  * @return 		: 无。
  138.  */
  139. void ap3216c_readdata(struct ap3216c_dev *dev)
  140. {
  141. 	unsigned char i =0;
  142.     unsigned char buf[6];
  143. 	
  144. 	/* 循环读取所有传感器数据 */
  145.     for(i = 0; i < 6; i++)	
  146.     {
  147.         buf[i] = ap3216c_read_reg(dev, AP3216C_IRDATALOW + i);	
  148.     }
  149.  
  150.     if(buf[0] & 0X80) 	/* IR_OF位为1,则数据无效 */
  151. 		dev->ir = 0;					
  152. 	else 				/* 读取IR传感器的数据   		*/
  153. 		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
  154. 	
  155. 	dev->als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
  156. 	
  157.     if(buf[4] & 0x40)	/* IR_OF位为1,则数据无效 			*/
  158. 		dev->ps = 0;    													
  159. 	else 				/* 读取PS传感器的数据    */
  160. 		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 
  161. }
  162.  
  163. /*
  164.  * @description		: 打开设备
  165.  * @param - inode 	: 传递给驱动的inode
  166.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  167.  * 					  一般在open的时候将private_data指向设备结构体。
  168.  * @return 			: 0 成功;其他 失败
  169.  */
  170. static int ap3216c_open(struct inode *inode, struct file *filp)
  171. {
  172. 	filp->private_data = &ap3216cdev;
  173.  
  174. 	/* 初始化AP3216C */
  175. 	ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x04);		/* 复位AP3216C 			*/
  176. 	mdelay(50);														/* AP3216C复位最少10ms 	*/
  177. 	ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X03);		/* 开启ALS、PS+IR 		*/
  178. 	return 0;
  179. }
  180.  
  181. /*
  182.  * @description		: 从设备读取数据 
  183.  * @param - filp 	: 要打开的设备文件(文件描述符)
  184.  * @param - buf 	: 返回给用户空间的数据缓冲区
  185.  * @param - cnt 	: 要读取的数据长度
  186.  * @param - offt 	: 相对于文件首地址的偏移
  187.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  188.  */
  189. static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
  190. {
  191. 	short data[3];
  192. 	long err = 0;
  193.  
  194. 	struct ap3216c_dev *dev = (struct ap3216c_dev *)filp->private_data;
  195. 	
  196. 	ap3216c_readdata(dev);
  197.  
  198. 	data[0] = dev->ir;
  199. 	data[1] = dev->als;
  200. 	data[2] = dev->ps;
  201. 	err = copy_to_user(buf, data, sizeof(data));
  202. 	return 0;
  203. }
  204.  
  205. /*
  206.  * @description		: 关闭/释放设备
  207.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  208.  * @return 			: 0 成功;其他 失败
  209.  */
  210. static int ap3216c_release(struct inode *inode, struct file *filp)
  211. {
  212. 	return 0;
  213. }
  214.  
  215. /* AP3216C操作函数 */
  216. static const struct file_operations ap3216c_ops = {
  217. 	.owner = THIS_MODULE,
  218. 	.open = ap3216c_open,
  219. 	.read = ap3216c_read,
  220. 	.release = ap3216c_release,
  221. };
  222.  
  223.  /*
  224.   * @description     : i2c驱动的probe函数，当驱动与
  225.   *                    设备匹配以后此函数就会执行
  226.   * @param - client  : i2c设备
  227.   * @param - id      : i2c设备ID
  228.   * @return          : 0，成功;其他负值,失败
  229.   */
  230. static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
  231. {
  232. 	/* 1、构建设备号 */
  233. 	if (ap3216cdev.major) {
  234. 		ap3216cdev.devid = MKDEV(ap3216cdev.major, 0);
  235. 		register_chrdev_region(ap3216cdev.devid, AP3216C_CNT, AP3216C_NAME);
  236. 	} else {
  237. 		alloc_chrdev_region(&ap3216cdev.devid, 0, AP3216C_CNT, AP3216C_NAME);
  238. 		ap3216cdev.major = MAJOR(ap3216cdev.devid);
  239. 	}
  240.  
  241. 	/* 2、注册设备 */
  242. 	cdev_init(&ap3216cdev.cdev, &ap3216c_ops);
  243. 	cdev_add(&ap3216cdev.cdev, ap3216cdev.devid, AP3216C_CNT);
  244.  
  245. 	/* 3、创建类 */
  246. 	ap3216cdev.class = class_create(THIS_MODULE, AP3216C_NAME);
  247. 	if (IS_ERR(ap3216cdev.class)) {
  248. 		return PTR_ERR(ap3216cdev.class);
  249. 	}
  250.  
  251. 	/* 4、创建设备 */
  252. 	ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL, AP3216C_NAME);
  253. 	if (IS_ERR(ap3216cdev.device)) {
  254. 		return PTR_ERR(ap3216cdev.device);
  255. 	}
  256.  
  257. 	ap3216cdev.private_data = client;
  258.  
  259. 	return 0;
  260. }
  261.  
  262. /*
  263.  * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
  264.  * @param - client 	: i2c设备
  265.  * @return          : 0，成功;其他负值,失败
  266.  */
  267. static int ap3216c_remove(struct i2c_client *client)
  268. {
  269. 	/* 删除设备 */
  270. 	cdev_del(&ap3216cdev.cdev);
  271. 	unregister_chrdev_region(ap3216cdev.devid, AP3216C_CNT);
  272.  
  273. 	/* 注销掉类和设备 */
  274. 	device_destroy(ap3216cdev.class, ap3216cdev.devid);
  275. 	class_destroy(ap3216cdev.class);
  276. 	return 0;
  277. }
  278.  
  279. /* 传统匹配方式ID列表 */
  280. static const struct i2c_device_id ap3216c_id[] = {
  281. 	{"alientek,ap3216c", 0},  
  282. 	{}
  283. };
  284.  
  285. /* 设备树匹配列表 */
  286. static const struct of_device_id ap3216c_of_match[] = {
  287. 	{ .compatible = "alientek,ap3216c" },		/* 需要和设备树下的保持一致 */
  288. 	{ /* Sentinel */ }
  289. };
  290.  
  291. /* i2c驱动结构体 */	
  292. static struct i2c_driver ap3216c_driver = {
  293. 	.probe = ap3216c_probe,
  294. 	.remove = ap3216c_remove,
  295. 	.driver = {						/* 设备树的匹配方法 */
  296. 			.owner = THIS_MODULE,
  297. 		   	.name = "ap3216c",
  298. 		   	.of_match_table = ap3216c_of_match, 	
  299. 		   },
  300. 	.id_table = ap3216c_id,			/* 传统驱动匹配方法 */
  301. };
  302. 		   
  303. /*
  304.  * @description	: 驱动入口函数
  305.  * @param 		: 无
  306.  * @return 		: 无
  307.  */
  308. static int __init ap3216c_init(void)
  309. {
  310. 	int ret = 0;
  311.  
  312. 	ret = i2c_add_driver(&ap3216c_driver);
  313. 	return ret;
  314. }
  315.  
  316. /*
  317.  * @description	: 驱动出口函数
  318.  * @param 		: 无
  319.  * @return 		: 无
  320.  */
  321. static void __exit ap3216c_exit(void)
  322. {
  323. 	i2c_del_driver(&ap3216c_driver);
  324. }
  325.  
  326. /* module_i2c_driver(ap3216c_driver) */
  327.  
  328. module_init(ap3216c_init);
  329. module_exit(ap3216c_exit);
  330. MODULE_LICENSE("GPL");
  331. MODULE_AUTHOR("sneak");

驱动详解可查阅注释及配合上诉的I2C驱动框架的框图及数据手册理解

我们通过 在终端输入 cat 指令可以读取到传感器的数值变量，如下图：

三、AP3216C的QT程序设计

IMX6ULL 的 QT-UI 的部署与实现需要依赖 QT 的很多依赖包，各位读者可以根据实际情况进行移植。或者直接使用正点原子提供的系统镜像！ 

3.1 Chart表制作

Qt Charts 很方便的绘制我们常见的曲线图、折线图、柱状图和饼状图等图表。不用自己花精力去了解第三方组件的使用了或者开发第三方组件。Qt 的帮助文档里已经有说明 Qt Charts 主要部件的使用方法。需要用到时我们可以查看 Qt 文档就可以了。

本项目中我们需要使用曲线图去展示 AP3216C 的 ALS 光强度属性。

使用一个 QSplineSeries 对象（曲线），一个 QChart（图表），一个 QChartView（图表视图）。首先我们创建坐 chart 图表，然后创建两条坐标轴 axisX 与 axisY。将两条坐标轴添加到 chart 图表上，再将 splineSeries 曲线与坐标轴连系起来。最后再将 chart 图表添加到 chartView 图表视图中。曲线上的数据由系统产生随机数，使用定时器更新数据。

qtchart.pro：

  1. QT       += core gui charts
  2.  
  3. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
  4.  
  5. CONFIG += c++11
  6.  
  7. # The following define makes your compiler emit warnings if you use
  8. # any Qt feature that has been marked deprecated (the exact warnings
  9. # depend on your compiler). Please consult the documentation of the
  10. # deprecated API in order to know how to port your code away from it.
  11. DEFINES += QT_DEPRECATED_WARNINGS
  12.  
  13. # You can also make your code fail to compile if it uses deprecated APIs.
  14. # In order to do so, uncomment the following line.
  15. # You can also select to disable deprecated APIs only up to a certain version of Qt.
  16. #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
  17.  
  18. SOURCES += \
  19.     main.cpp \
  20.     mainwindow.cpp
  21.  
  22. HEADERS += \
  23.     mainwindow.h
  24.  
  25. FORMS += \
  26.     mainwindow.ui
  27.  
  28. # Default rules for deployment.
  29. qnx: target.path = /tmp/$${TARGET}/bin
  30. else: unix:!android: target.path = /opt/$${TARGET}/bin
  31. !isEmpty(target.path): INSTALLS += target

mainwindow.h：

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3. #include <QChartView>
  4. #include <QSplineSeries>
  5. #include <QScatterSeries>
  6. #include <QDebug>
  7. #include <QValueAxis>
  8. #include <QTimer>
  9. #include <QMainWindow>
  10.  
  11. /*  必需添加命名空间 */
  12. QT_CHARTS_USE_NAMESPACE
  13.  
  14. class MainWindow : public QMainWindow
  15. {
  16.     Q_OBJECT
  17.  
  18. public:
  19.     MainWindow(QWidget *parent = nullptr);
  20.     ~MainWindow();
  21.  
  22. private:
  23.     /* 接收数据接口 */
  24.     void receivedData(int);
  25.  
  26.     /* 数据最大个数 */
  27.     int maxSize;
  28.  
  29.     /* x轴上的最大值 */
  30.     int maxX;
  31.  
  32.     /* y轴上的最大值 */
  33.     int maxY;
  34.  
  35.     /* y轴 */
  36.     QValueAxis *axisY;
  37.  
  38.     /* x轴 */
  39.     QValueAxis *axisX;
  40.  
  41.     /* QList int类型容器 */
  42.     QList<int> data;
  43.  
  44.     /* QSplineSeries对象（曲线）*/
  45.     QSplineSeries *splineSeries;
  46.  
  47.     /* QChart图表 */
  48.     QChart *chart;
  49.  
  50.     /* 图表视图 */
  51.     QChartView *chartView;
  52.  
  53.     /* 定时器 */
  54.     QTimer *timer;
  55.  
  56. private slots:
  57.     void timerTimeOut();
  58. };
  59. #endif // MAINWINDOW_H

mainwindow.c：

  1. #include "mainwindow.h"
  2. #include <QDateTime>
  3. MainWindow::MainWindow(QWidget *parent)
  4.     : QMainWindow(parent)
  5. {
  6.     /* 设置最显示位置与大小 */
  7.     this->setGeometry(0, 0, 800, 480);
  8.     /* 最大储存maxSize - 1个数据 */
  9.     maxSize = 51;
  10.     /* x轴上的最大值 */
  11.     maxX = 5000;
  12.     /* y轴最大值 */
  13.     maxY = 40;
  14.  
  15.     /* splineSeries曲线实例化（折线用QLineSeries） */
  16.     splineSeries = new QSplineSeries();
  17.     /* 图表实例化 */
  18.     chart = new QChart();
  19.     /* 图表视图实例化 */
  20.     chartView = new QChartView();
  21.  
  22.     /* 坐标轴 */
  23.     axisY = new QValueAxis();
  24.     axisX = new QValueAxis();
  25.     /* 定时器 */
  26.     timer = new QTimer(this);
  27.  
  28.     /* legend译图例类型，以绘图的颜色区分，本例设置为隐藏 */
  29.     chart->legend()->hide();
  30.     /* chart设置标题 */
  31.     chart->setTitle("实时动态曲线示例");
  32.     /* 添加一条曲线splineSeries */
  33.     chart->addSeries(splineSeries);
  34.  
  35.     /* 设置显示格式 */
  36.     axisY->setLabelFormat("%i");
  37.     /* y轴标题 */
  38.     axisY->setTitleText("温度/℃");
  39.     /* y轴标题位置（设置坐标轴的方向） */
  40.     chart->addAxis(axisY, Qt::AlignLeft);
  41.     /* 设置y轴范围 */
  42.     axisY->setRange(0, maxY);
  43.     /* 将splineSeries附加于y轴上 */
  44.     splineSeries->attachAxis(axisY);
  45.  
  46.     /* 设置显示格式 */
  47.     axisX->setLabelFormat("%i");
  48.     /* x轴标题 */
  49.     axisX->setTitleText("时间/ms");
  50.     /* x轴标题位置（设置坐标轴的方向） */
  51.     chart->addAxis(axisX, Qt::AlignBottom);
  52.     /* 设置x轴范围 */
  53.     axisX->setRange(0, maxX);
  54.     /* 将splineSeries附加于x轴上 */
  55.     splineSeries->attachAxis(axisX);
  56.  
  57.     /* 将图表的内容设置在图表视图上 */
  58.     chartView->setChart(chart);
  59.     /* 设置抗锯齿 */
  60.     chartView->setRenderHint(QPainter::Antialiasing);
  61.  
  62.     /* 设置为图表视图为中心部件 */
  63.     setCentralWidget(chartView);
  64.  
  65.     /* 定时200ms */
  66.     timer->start(200);
  67.     /* 信号槽连接 */
  68.     connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeOut()));
  69.  
  70.     /* 设置随机种子，随机数初始化 */
  71.     qsrand(time(NULL));
  72. }
  73.  
  74. MainWindow::~MainWindow()
  75. {
  76. }
  77.  
  78. void MainWindow::timerTimeOut()
  79. {
  80.     /* 产生随机0~maxY之间的数据 */
  81.     receivedData(qrand() % maxY );
  82. }
  83.  
  84. void MainWindow::receivedData(int value)
  85. {
  86.     /* 将数据添加到data中 */
  87.     data.append(value);
  88.  
  89.     /* 当储存数据的个数大于最大值时，把第一个数据删除 */
  90.     while (data.size() > maxSize) {
  91.         /* 移除data中第一个数据 */
  92.         data.removeFirst();
  93.     }
  94.  
  95.     /* 先清空 */
  96.     splineSeries->clear();
  97.  
  98.     /* 计算x轴上的点与点之间显示的间距 */
  99.     int xSpace = maxX / (maxSize - 1);
  100.  
  101.     /* 添加点，xSpace * i 表示第i个点的x轴的位置 */
  102.     for (int i = 0; i < data.size(); ++i) {
  103.         splineSeries->append(xSpace * i, data.at(i));
  104.     }
  105. }

QT Chart表效果：

3.2 AP3216C的数据读取

我们编写 QT 下的 AP3216C 的应用代码：

ap3216c.h：

  1. #ifndef AP3216C_H
  2. #define AP3216C_H
  3.  
  4. #include <QObject>
  5. #include <QTimer>
  6.  
  7. class Ap3216c : public QObject
  8. {
  9.     Q_OBJECT
  10.  
  11. public:
  12.     explicit Ap3216c(QObject *parent = 0);     //构造函数声明,"explicit"是一个C++关键字，用于修饰构造函数或函数，以禁止隐式转换
  13.     ~Ap3216c();                                 //析构函数
  14.  
  15.     Q_INVOKABLE void setCapture(bool str);      //Q_INVOKABLE是一个宏，setCapture函数接受一个bool类型的参数str，用于设置某个对象的捕获状态
  16.  
  17.     QString alsData();      //光强传感器（ ALS: Ambient Light Sensor）
  18.     QString psData();       //接近传感器（ PS: Proximity Sensor）
  19.     QString irData();       //红外 LED（ IR LED）
  20.  
  21. private:
  22.     QTimer *timer;          //定时器timer
  23.     QString alsdata;        //光强数据
  24.     QString psdata;         //接近数据
  25.     QString irdata;         //红外数据
  26.  
  27.     QString readAlsData();  //读取Ais数据
  28.     QString readPsData();   //读取Ps数据
  29.     QString readIrData();   //读取IR数据
  30.  
  31.     Q_PROPERTY(QString alsData READ alsData NOTIFY ap3216cDataChanged)
  32.     Q_PROPERTY(QString psData READ psData NOTIFY ap3216cDataChanged)
  33.     Q_PROPERTY(QString irData READ irData NOTIFY ap3216cDataChanged)
  34.     /*Q_PROPERTY：这是一个宏，用于在类中声明属性。
  35.      *QString：alsData是属性的类型，这里是一个QString类型的变量。
  36.      *READ alsData：这表示该属性可以通过"alsData"方法进行读取。
  37.      *NOTIFY ap3216cDataChanged：这表示当该属性发生变化时，会发出"ap3216cDataChanged"信号
  38.      */
  39.  
  40. public slots:
  41.     void timer_timeout();
  42.  
  43. signals:
  44.     void ap3216cDataChanged();
  45. };
  46.  
  47. #endif // AP3216C_H

ap3216c.c：

  1. #include "ap3216c.h"
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <unistd.h>
  8. #include <QDebug>
  9.  
  10. /* AP3216C的构造函数 */
  11. Ap3216c::Ap3216c(QObject *parent) : QObject (parent)
  12. {
  13.     timer = new QTimer();                                            //定义一个定时器容器
  14.     connect(timer, SIGNAL(timeout()),this,SLOT(timer_timeout()));     //将超时信号，与timer_timeout链接起来
  15. }
  16.  
  17. /* 析构函数 */
  18. Ap3216c::~Ap3216c()
  19. {
  20.  
  21. }
  22.  
  23. /* 超时函数 */
  24. void Ap3216c::timer_timeout()
  25. {
  26.     alsdata = readAlsData();
  27.     psdata = readPsData();
  28.     irdata = readIrData();
  29.     emit ap3216cDataChanged();      //发送ap3216c数值变化信息
  30. }
  31.  
  32. QString Ap3216c::readIrData()
  33. {
  34.     char const *filename = "/sys/class/misc/ap3216c/ir";
  35.     int err = 0;
  36.     int fd;
  37.     char buf[10];
  38.  
  39.     fd = open(filename,O_RDONLY);      //只读模式打开文件
  40.     if(fd < 0){
  41.         close(fd);
  42.         return "open file error!";
  43.     }
  44.  
  45.     err = read(fd,buf,sizeof(buf));
  46.     if(err < 0){
  47.         close(fd);
  48.         return "read data error!";
  49.     }
  50.     close(fd);
  51.  
  52.     QString irValue = buf;
  53.     QStringList list = irValue.split("\n");     //将irValue按照换行符"\n"分割成一个字符串列表，并将结果存储在list对象中
  54.     return list[0];
  55. }
  56.  
  57. QString Ap3216c::readPsData()
  58. {
  59.     char const *filename = "/sys/class/misc/ap3216c/ps";
  60.     int err = 0;
  61.     int fd;
  62.     char buf[10];
  63.  
  64.     fd = open(filename,O_RDONLY);       //只读模式打开文件
  65.     if(fd < 0){
  66.         close(fd);
  67.         return "open file error!";
  68.     }
  69.  
  70.     err = read(fd,buf,sizeof(buf));
  71.     if(err < 0){
  72.         close(fd);
  73.         return "read data error!";
  74.     }
  75.     close(fd);
  76.  
  77.     QString irValue = buf;
  78.     QStringList list = irValue.split("\n");     //将irValue按照换行符"\n"分割成一个字符串列表，并将结果存储在list对象中
  79.     return list[0];
  80. }
  81.  
  82. QString Ap3216c::readAlsData()
  83. {
  84.     char const *filename = "/sys/class/misc/ap3216c/als";
  85.     int err = 0;
  86.     int fd;
  87.     char buf[10];
  88.  
  89.     fd = open(filename,O_RDONLY);       //只读模式打开文件
  90.     if(fd < 0){
  91.         close(fd);
  92.         return "open file error!";
  93.     }
  94.  
  95.     err = read(fd,buf,sizeof(buf));
  96.     if(err < 0){
  97.         close(fd);
  98.         return "read data error!";
  99.     }
  100.     close(fd);
  101.  
  102.     QString irValue = buf;
  103.     QStringList list = irValue.split("\n");     //将irValue按照换行符"\n"分割成一个字符串列表，并将结果存储在list对象中
  104.     return list[0];
  105. }
  106.  
  107. QString Ap3216c::alsData()
  108. {
  109.     return alsdata;
  110. }
  111.  
  112. QString Ap3216c::irData()
  113. {
  114.     return irdata;
  115. }
  116.  
  117. QString Ap3216c::psData()
  118. {
  119.     return psdata;
  120. }
  121.  
  122. void Ap3216c::setCapture(bool str)
  123. {
  124.     if(str)
  125.         timer->start(500);
  126.     else
  127.         timer->stop();
  128. }

“Linux 系统之下一切皆文件”，上述代码就是通过 C 语言库函数去读取系统下的属性数值信息来做到获取 AP3216C 的数据值！

3.3 AP3216C与Chart联动

我们将 AP3216C 与 Chart 进行联动配合，通过 Chart 实时读取显示 AP3216C 的 ALS 属性。

mainwindow.h：

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3.  
  4. #include <QMainWindow>
  5. #include <QVBoxLayout>
  6. #include <QHBoxLayout>
  7. #include <QComboBox>
  8. #include <QPushButton>
  9. #include <QVBoxLayout>
  10. #include <QLabel>
  11. #include <QScrollArea>
  12. #include <QDebug>
  13. #include <QChartView>
  14. #include <QSplineSeries>
  15. #include <QScatterSeries>
  16. #include <QDebug>
  17. #include <QValueAxis>
  18. #include "ap3216c.h"
  19.  
  20. /*  必需添加命名空间 */
  21. QT_CHARTS_USE_NAMESPACE
  22.  
  23. class MainWindow : public QMainWindow
  24. {
  25.     Q_OBJECT
  26.  
  27. public:
  28.     MainWindow(QWidget *parent = nullptr);
  29.     ~MainWindow();
  30.  
  31. private:
  32.     /* 主容器，Widget也可以当作一种容器 */
  33.     QWidget *mainWidget;
  34.  
  35.     /* 界面水平区域布局 */
  36.     QHBoxLayout *hboxLayout[2];
  37.  
  38.     /* 界面右侧区域布局 */
  39.     QVBoxLayout *vboxLayout[4];
  40.  
  41.     /* 界面右侧区域容器 */
  42.     QWidget *rightWidget;
  43.  
  44.     /* 用一个 QLabel 对象用于显示字符串 */
  45.     QLabel *labelString;
  46.  
  47.     /* 容器作用，用于布局 */
  48.     QWidget *widget[5];
  49.  
  50.     /* 标签文本 */
  51.     QLabel *label[3];
  52.  
  53.     /* 数据标签 */
  54.     QLabel *my_label[3];
  55.  
  56.     /* 数据最大个数 */
  57.     int maxSize;
  58.  
  59.     /* x轴上的最大值 */
  60.     int maxX;
  61.  
  62.     /* y轴上的最大值 */
  63.     int maxY;
  64.  
  65.     /* y轴 */
  66.     QValueAxis *axisY;
  67.  
  68.     /* x轴 */
  69.     QValueAxis *axisX;
  70.  
  71.     /* QList int类型容器 */
  72.     QList<int> data;
  73.  
  74.     /* QSplineSeries对象（曲线）*/
  75.     QSplineSeries *splineSeries;
  76.  
  77.     /* QChart图表 */
  78.     QChart *chart;
  79.  
  80.     /* 图表视图 */
  81.     QChartView *chartView;
  82.  
  83.     /* ii2传感器类 */
  84.     Ap3216c *ap3216c;
  85.  
  86.     /* 接收数据接口 */
  87.     void receivedData(int);
  88.  
  89.     /* 布局初始化 */
  90.     void layoutInit();
  91.  
  92.  
  93. private slots:
  94.     /* 获取ap3216传感器数据 */
  95.     void getAp3216cData();
  96. };
  97. #endif // MAINWINDOW_H

mainwindow.c：

  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include <QGuiApplication>
  4. #include <QScreen>
  5. #include <QDebug>
  6.  
  7. MainWindow::MainWindow(QWidget *parent)
  8.     : QMainWindow(parent)
  9. {
  10.     /* 布局初始化 */
  11.     layoutInit();
  12. }
  13.  
  14. MainWindow::~MainWindow()
  15. {
  16. }
  17.  
  18. /* 布局初始化 */
  19. void MainWindow::layoutInit()
  20. {
  21.     /* 获取屏幕的分辨率，Qt官方建议使用这
  22.      * 种方法获取屏幕分辨率，防上多屏设备导致对应不上
  23.      * 注意，这是获取整个桌面系统的分辨率
  24.      */
  25.     QList <QScreen *> list_screen = QGuiApplication::screens();
  26.  
  27.     /* 如果是ARM平台，直接设置大小为屏幕的大小 */
  28. #if __arm__
  29.     /* 重设大小 */
  30.     this->resize(list_screen.at(0)->geometry().width(),
  31.                  list_screen.at(0)->geometry().height());
  32. #else
  33.     /* 否则则设置主窗体大小为800x480 */
  34.     this->resize(800,400);
  35. #endif
  36.  
  37.     /* 实例化与布局，常规操作 */
  38.     mainWidget = new QWidget();
  39.     rightWidget = new QWidget();
  40.  
  41.     for(int i = 0; i < 2; i++)          //水平布局
  42.         hboxLayout[i] = new QHBoxLayout();
  43.  
  44.     for(int i = 0; i < 5; i++)          //容器布局
  45.         widget[i] = new QWidget();
  46.  
  47.     for(int i = 0; i < 4; i++)          //垂直布局
  48.         vboxLayout[i] = new QVBoxLayout();
  49.  
  50.     for(int i = 0; i < 3; i++)          //数据变量
  51.         my_label[i] = new QLabel();
  52.  
  53.  
  54. /********************** chart表格 *****************************/
  55.     /* 最大储存maxSize - 1个数据 */
  56.     maxSize = 51;
  57.     /* x轴上的最大值 */
  58.     maxX = 5000;
  59.     /* y轴最大值 */
  60.     maxY = 40;
  61.  
  62.     /* splineSeries曲线实例化（折线用QLineSeries） */
  63.     splineSeries = new QSplineSeries();
  64.     /* 图表实例化 */
  65.     chart = new QChart();
  66.     /* 图表视图实例化 */
  67.     chartView = new QChartView();
  68.  
  69.     /* 坐标轴 */
  70.     axisY = new QValueAxis();
  71.     axisX = new QValueAxis();
  72.  
  73.     /* legend译图例类型，以绘图的颜色区分，本例设置为隐藏 */
  74.     chart->legend()->hide();
  75.     /* chart设置标题 */
  76.     chart->setTitle("环境光强度");
  77.     /* 添加一条曲线splineSeries */
  78.     chart->addSeries(splineSeries);
  79.  
  80.     /* 设置显示格式 */
  81.     axisY->setLabelFormat("%i");
  82.     /* y轴标题 */
  83.     axisY->setTitleText("光通亮/Lux");
  84.     /* y轴标题位置（设置坐标轴的方向） */
  85.     chart->addAxis(axisY, Qt::AlignLeft);
  86.     /* 设置y轴范围 */
  87.     axisY->setRange(0, maxY);
  88.     /* 将splineSeries附加于y轴上 */
  89.     splineSeries->attachAxis(axisY);
  90.  
  91.     /* 设置显示格式 */
  92.     axisX->setLabelFormat("%i");
  93.     /* x轴标题 */
  94.     axisX->setTitleText("时间/ms");
  95.     /* x轴标题位置（设置坐标轴的方向） */
  96.     chart->addAxis(axisX, Qt::AlignBottom);
  97.     /* 设置x轴范围 */
  98.     axisX->setRange(0, maxX);
  99.     /* 将splineSeries附加于x轴上 */
  100.     splineSeries->attachAxis(axisX);
  101.  
  102.     /* 将图表的内容设置在图表视图上 */
  103.     chartView->setChart(chart);
  104.     /* 设置抗锯齿 */
  105.     chartView->setRenderHint(QPainter::Antialiasing);
  106. /********************** chart表格 *****************************/
  107.  
  108.     /* 设置传感器数据标签 */
  109.     QFont font;
  110.     font.setPixelSize(18);
  111.  
  112.     QPalette pal;
  113.     pal.setColor(QPalette::WindowText, Qt::black);
  114.  
  115.     QStringList list;
  116.     list<<"环境光强度："<<"接近距离："<<"红外强度：";
  117.     for (int i = 0; i < 3; i++) {
  118.         label[i] = new QLabel();
  119.         label[i]->setText(list[i]);
  120.         label[i]->setFont(font);
  121.         label[i]->setPalette(pal);
  122.         label[i]->adjustSize();
  123.     }
  124.  
  125.     /* 垂直容器布局 */
  126.     vboxLayout[3]->addWidget(widget[0]);
  127.     vboxLayout[3]->addWidget(widget[1]);
  128.     vboxLayout[3]->addWidget(widget[2]);
  129.  
  130.     hboxLayout[0]->addWidget(chartView);        //将chart表格添加到水平布局中
  131.  
  132.     widget[3]->setLayout(hboxLayout[0]);
  133.     widget[4]->setLayout(vboxLayout[3]);
  134.  
  135.     hboxLayout[1]->addWidget(widget[3]);
  136.     hboxLayout[1]->addWidget(widget[4]);
  137.  
  138.     mainWidget->setLayout(hboxLayout[1]);
  139.  
  140.     this->setCentralWidget(mainWidget);
  141.  
  142.     /* als布局 */
  143.     vboxLayout[0]->addWidget(label[0]);
  144.     vboxLayout[0]->addWidget(my_label[0]);
  145.     vboxLayout[0]->setAlignment(Qt::AlignTop | Qt::AlignVCenter);
  146.     widget[0]->setLayout(vboxLayout[0]);
  147.  
  148.     /* ps布局 */
  149.     vboxLayout[1]->addWidget(label[1]);
  150.     vboxLayout[1]->addWidget(my_label[1]);
  151.     vboxLayout[1]->setAlignment(Qt::AlignTop | Qt::AlignVCenter);
  152.     widget[1]->setLayout(vboxLayout[1]);
  153.  
  154.     /* ir布局 */
  155.     vboxLayout[2]->addWidget(label[2]);
  156.     vboxLayout[2]->addWidget(my_label[2]);
  157.     vboxLayout[2]->setAlignment(Qt::AlignTop | Qt::AlignVCenter);
  158.     widget[2]->setLayout(vboxLayout[2]);
  159.  
  160.     ap3216c = new Ap3216c(this);
  161.  
  162.     /* 只能在开发板上开启获取数据，Ubuntu上是没有ap3216c传感器的 */
  163. #if __arm__
  164.     ap3216c->setCapture(true);
  165. #endif
  166.  
  167.     connect(ap3216c,SIGNAL(ap3216cDataChanged()),this,SLOT(getAp3216cData()));
  168. }
  169.  
  170. void MainWindow::getAp3216cData()
  171. {
  172.     static QString als = ap3216c->alsData();
  173. //    if (als != ap3216c->alsData()) {
  174. //        als = ap3216c->alsData();
  175. //    }
  176.     als = ap3216c->alsData();
  177.  
  178.     static QString ps = ap3216c->psData();
  179. //    if (ps != ap3216c->psData()) {
  180. //        ps = ap3216c->psData();
  181. //    }
  182.  
  183.     ps = ap3216c->psData();
  184.  
  185.     static QString ir = ap3216c->irData();
  186. //    if (ir != ap3216c->irData()) {
  187. //        ir = ap3216c->irData();
  188. //    }
  189.  
  190.     ir = ap3216c->irData();
  191.  
  192.     my_label[0]->setText(als);
  193.     my_label[1]->setText(ps);
  194.     my_label[2]->setText(ir);
  195.  
  196.  
  197. /**************** chart表数据 ******************/
  198.  
  199.     int num = als.toInt();      //字符串转int类型数据
  200.  
  201.     /* 将数据添加到data中 */
  202.     data.append(num);
  203.  
  204.     /* 当储存数据的个数大于最大值时，把第一个数据删除 */
  205.     while (data.size() > maxSize) {
  206.         /* 移除data中第一个数据 */
  207.         data.removeFirst();
  208.     }
  209.  
  210.     /* 先清空 */
  211.     splineSeries->clear();
  212.  
  213.     /* 计算x轴上的点与点之间显示的间距 */
  214.     int xSpace = maxX / (maxSize - 1);
  215.  
  216.     /* 添加点，xSpace * i 表示第i个点的x轴的位置 */
  217.     for (int i = 0; i < data.size(); ++i) {
  218.         splineSeries->append(xSpace * i, data.at(i));
  219.     }
  220.  
  221. }

AP3216C 与 Chart 联动的程序主要是进行 QT 的容器布局，通过 layoutInit() 函数进行布局初始化（UI设计部分），之后通过定时 timer 去定时读取 ap3216c 的传感器数据，在读取 ap3216c 的数据之后，通过 Chart 进行绘制出来！

实际项目：

四、项目效果

AP3216C+QT+Chart

五、项目代码

代码地址：基于IMX6ULL的AP3216C的QT动态数据曲线图显示代码资源-CSDN文库

如果积分不够的朋友，点波关注，评论区留下邮箱，作者无偿提供源码和后续问题解答。求求啦关注一波吧 ！！！

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号