devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于深度学习的轴承故障诊断系统_基于深度学习的轴承故障检测系统

作者：煮酒与君饮 | 2024-07-23 05:07:41

赞

踩

基于深度学习的轴承故障检测系统

0 引言

        一种基于深度学习的轴承故障诊断系统，对振动信号进行监测，实现从数据采集到特征识别的端到端智能故障诊断。

          基于I.MX6ULL进行开发，完成IIC总线框架下的adxl345振动传感器驱动程序编写，其采用中断读取数据；下位机应用层采用QT多线程同步处理驱动层异步通知信号，实现不同频率下的数据采集，以及数据的实时绘制、网络传输等；开发windows客户端，在Qt中部署pytorch训练的神经网络模型，对来自下位机的数据进行特征识别，以及如频域实时绘制、监测信息显示、数据处理等功能。其主要功能如下表所示：

下位机（I.MX6ULL）

数据采集控制（6.25hz-3200hz频率选择、量程设置、采样方向）

开发环境及相应技术：

ARM-linux-gcc

、arm-poky-linux-gnueabi-gcc

Qt多线程、socket网络、界面、信号与槽、linux C、

Linux 驱动、C++、pytorch、libtorch

时域数据实时绘制（≥800hz就会出现卡顿）

网络数据传输与接收/服务器端

故障报警（蜂鸣器）

上位机(windows 客户端）

数据接收与发送/客户端

故障诊断（特征识别）

接受下位机的状态信息进行参数更新

实时傅里叶变换、时域特征参数计算并显示

其他（模型加载、数据保存、绘图、数据导入导出等）

离线数据分析系统（全局、局部数据处理等）

    界面示意图如下图等所示：

        上位机登录界面：

        上位机（在线监测界面与离线分析界面）：

         下位机示意图：

         诊断结果显示：

 1 下位机数据采集

1.1 传感器驱动

        传感器采用adxl345数字振动传感器，量程最高为±16g,采样频率为3200hz，根据奈奎斯特采样定理，获取到的最大信息在1600hz以内。驱动程序主要采用platform框架、iic协议读取数据、中断实现高速和低速数据采集（中断下半部读取adxl345的fifo然后使用异步通知使应用层读取数据）、利用IIO框架对传感器参数进行设置。（最开始想利用IIO框架的触发器和缓冲区来实现数据采集，后面发现并不能达到一定频率下的实时数据，所以利用中断来读取数据，但IIO框架也没有删除，利用互斥锁机制来对数据读取和写入进行保护）。

  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 <linux/of_irq.h>
  19. #include <linux/irq.h>
  20. #include <linux/regmap.h>
  21. #include <linux/iio/iio.h>
  22. #include <linux/iio/sysfs.h>
  23. #include <linux/iio/buffer.h>
  24. #include <linux/iio/trigger.h>
  25. #include <linux/iio/triggered_buffer.h>
  26. #include <linux/iio/trigger_consumer.h>
  27. #include <linux/types.h>
  28. #include <linux/unaligned/be_byteshift.h>
  29. #include "adxl345.h"
  30.  
  31. #define DATA_SIZE	32
  32. #define ADXL345_CNT 1
  33. #define ADXL345_NAME "adxl345"
  34. #define ADXL345_INTERRUPT_NAME	"ADXL345"
  35. #define ADXL345_CHAN(_type, _channel2, _index)                    \
  36. 	{                                                             \
  37. 		.type = _type,                                        \
  38. 		.modified = 1,                                        \
  39. 		.channel2 = _channel2,                                \
  40. 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_FREQUENCY), \
  41. 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	      \
  42. 				      BIT(IIO_CHAN_INFO_CALIBBIAS),   \
  43. 		.scan_index = _index,                                 \
  44. 		.scan_type = {                                        \
  45. 				.sign = 's',                          \
  46. 				.realbits = 16,                       \
  47. 				.storagebits = 16,                    \
  48. 				.shift = 0,                           \
  49. 				.endianness = IIO_BE,                 \
  50. 			     },                                       \
  51. 	}
  52. static short BUF_DATA_X_Y_Z[DATA_SIZE];							
  53. unsigned char X_Y_Z_FLAG=2;	        /*采样方向，默认Z轴*/
  54. static int interrupt_conter=0;      /*中断计数*/
  55. /* adxl345的扫描元素，三路振动数据*/
  56. enum inv_adxl345_scan {
  57.     INV_ADXL345_SCAN_ACCL_X,
  58.     INV_ADXL345_SCAN_ACCL_Y,
  59.     INV_ADXL345_SCAN_ACCL_Z,
  60. };
  61. /*
  62.  * 扫描掩码，两种情况，全启动0X111，或者都不启动0X0
  63.  */
  64. static const unsigned long adxl345_scan_masks[]={
  65. 	BIT(INV_ADXL345_SCAN_ACCL_X)|
  66. 	BIT(INV_ADXL345_SCAN_ACCL_Y) |
  67. 	BIT(INV_ADXL345_SCAN_ACCL_Z) ,
  68. 	0,
  69. };
  70. static const struct iio_chan_spec adxl345_channels[] = 
  71. {
  72. 	ADXL345_CHAN(IIO_ACCEL,IIO_MOD_X,INV_ADXL345_SCAN_ACCL_X),
  73. 	ADXL345_CHAN(IIO_ACCEL,IIO_MOD_Y,INV_ADXL345_SCAN_ACCL_Y),
  74. 	ADXL345_CHAN(IIO_ACCEL,IIO_MOD_Z,INV_ADXL345_SCAN_ACCL_Z),
  75. };
  76. /*设备结构体*/
  77. struct adxl345_dev 
  78. {
  79. 	dev_t devid;			            /* 设备号 	 */
  80. 	struct cdev cdev;		            /* cdev 	*/
  81. 	struct class *class;	            /* 类 		*/
  82. 	struct device *device;	            /* 设备 	 */
  83. 	int major;			                /* 主设备号 */
  84. 	struct i2c_client *client;			/* i2c 设备 */
  85. 	struct mutex lock;
  86. 	int irqnum;
  87. 	irqreturn_t (*handler)(int ,void *);
  88. 	struct work_struct adxl345_irq_work;        
  89. 	struct device_node *nd;  
  90. 	int gpio;
  91. 	struct fasync_struct *async_queue;  /* 异步相关结构体 */
  92. };
  93. static	struct adxl345_dev  *myprivate_data;						/* 私有数据 */ 
  94.  /* 以正负2g量程为例，4/2^13=，扩大10^9倍，就是488280加速度计分辨率*/
  95. static const int accel_scale_adxl345[] = 
  96. {488280,976560,1953120,3906250};
  97. /* 输出速率*/
  98. static const int accel_frequency_adxl345[]=
  99. {0.10,0.20,0.39,0.78,1.56,3.13,6.25,12.5,25,50,100,200,400,800,1600,3200};
  100. /*
  101.  * @description:  iic从adxl345读取寄存器的值
  102.  * @para-dev adxl345设备 reg 要读取的寄存器  val 读取数据缓冲区 len 要读取的数据长度
  103.  */
  104. static int adxl345_read_regs(struct adxl345_dev *dev, u8 reg, void *val, int len)
  105. {
  106. 	int ret=0;
  107. 	struct i2c_msg msg[2];
  108. 	struct i2c_client *client = dev->client;
  109. 	/* msg[0]为发送要读取的首地址 */
  110. 	msg[0].addr = client->addr;			/* adxl345地址 */
  111. 	msg[0].flags = 0;					/* 标记为发送数据 */
  112. 	msg[0].buf = &reg;					/* 读取的寄存器首地址 */
  113. 	msg[0].len = 1;						/* reg长度*/
  114. 	/* msg[1]读取数据 */
  115. 	msg[1].addr = client->addr;			/* adxl345地址 */
  116. 	msg[1].flags = I2C_M_RD;			/* 标记为读取数据*/
  117. 	msg[1].buf = val;					/* 读取数据缓冲区 */
  118. 	msg[1].len = len;					/* 要读取的数据长度*/
  119. 	ret=i2c_transfer(client->adapter, msg, 2);
  120. 	if(ret==2)
  121. 	    	ret=0;
  122. 	else
  123. 	  	ret=-EREMOTEIO;
  124. 	return ret;
  125. }
  126. /*
  127.  * @description:  iic从adxl345写值
  128.  * @para-dev adxl345设备 reg 要写的寄存器  buf 写数据缓冲区 len 要写的数据长度
  129.  */
  130. static int adxl345_write_regs(struct adxl345_dev *dev, u8 reg, u8 *buf, u8 len)
  131. {
  132. 	int ret;
  133. 	u8 b[256];
  134. 	struct i2c_msg msg;
  135. 	struct i2c_client *client =dev->client;
  136. 	b[0] = reg;					/* 寄存器首地址 */
  137. 	memcpy(&b[1],buf,len);		/* 将要写入的数据拷贝到数组b里面 */	
  138. 	msg.addr = client->addr;	/* adxl345地址 */
  139. 	msg.flags = 0;				/* 标记为写数据 */
  140. 	msg.buf = b;				/* 要写入的数据缓冲区 */ /*根据iic时序  adxl345*/
  141. 	msg.len = len + 1;			/* 要写入的数据长度，加上寄存器地址的长度*/ 
  142. 	ret= i2c_transfer(client->adapter, &msg, 1);
  143. 	if(ret==1)
  144. 	  		ret=0;
  145. 	else
  146. 	  	ret=-EREMOTEIO;
  147. 	return ret;
  148. }
  149. /*
  150.  * @description:  向adxl345指定寄存器读一个寄存器的值
  151.  * @param -dev:   adxl345设备
  152.  * @param - reg:  要读的寄存器
  153.  * @return 
  154.  */
  155. static u8 adxl345_read_reg(struct adxl345_dev *dev, u8 reg)
  156. {
  157. 	u8 data = 0;
  158. 	adxl345_read_regs(dev, reg, &data, 1);
  159. 	return data;
  160. }
  161. /*
  162.  * @description	: 向adxl345指定寄存器写入指定的值，写一个寄存器
  163.  * @param - dev:  adxl345设备
  164.  * @param - reg:  要写的寄存器
  165.  * @param - data: 要写入的值
  166.  * @return   :    无
  167.  */
  168. static void adxl345_write_reg(struct adxl345_dev *dev, u8 reg, u8 data)
  169. {
  170. 	u8 buf = 0;
  171. 	buf = data;
  172. 	adxl345_write_regs(dev, reg, &buf, 1);
  173. }
  174. /*利用IIO框架读取adxl345寄存器的数据*/
  175. static int adxl345_read_channel_data(struct iio_dev *indio_dev,
  176. 					 struct iio_chan_spec const *chan,
  177. 					 int *val)
  178. {
  179. 	int ind;
  180. 	__be16 d ;
  181. 	int axis=chan->channel2;
  182. 	struct adxl345_dev *dev=iio_priv(indio_dev);
  183. 	ind = (axis - IIO_MOD_X) * 2;
  184. 	adxl345_read_regs(dev,DATAX0+ind,(u8*)&d,2);//  大端：d[0]低地址 d[1]高地址
  185. 	*val=(short)d;
  186. 	return IIO_VAL_INT;
  187. }
  188.  /*
  189. * @description : 读函数，当读取 sysfs 中的文件的时候最终此函数会执，
  190.     此函数里面会从传感器里面读取各种数据，然后上传给应用。
  191. * @param - indio_dev : iio_dev
  192. * @param - chan : 通道
  193. * @param - val : 读取的值，如果是小数值的话，val 是整数部分。
  194. * @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
  195. * @param - mask : 掩码。
  196. */
  197. static int adxl345_read_raw(struct iio_dev *indio_dev,
  198. 			   struct iio_chan_spec const *chan,
  199. 			   int *val, int *val2, long mask)
  200. {
  201. 	struct adxl345_dev *dev=iio_priv(indio_dev);
  202. 	int ret = 0;
  203. 	unsigned char regdata = 0;
  204. 	switch (mask){
  205. 	case IIO_CHAN_INFO_RAW:
  206. 		mutex_lock(&dev->lock);
  207. 		ret = adxl345_read_channel_data(indio_dev, chan, val); 	/* 读取通道值 */
  208. 		mutex_unlock(&dev->lock);	
  209. 		return ret;
  210. 		break;
  211. 	case IIO_CHAN_INFO_SCALE:
  212. 		mutex_lock(&dev->lock);
  213. 		regdata=(adxl345_read_reg(dev,DATA_FORMAT)&0x3);
  214. 		mutex_unlock(&dev->lock);
  215. 		*val=0;
  216. 		*val2=accel_scale_adxl345[regdata];	
  217. 		return IIO_VAL_INT_PLUS_NANO;/*组合宏， 值为val+val2/1000000000 */
  218. 		break;
  219. 	case IIO_CHAN_INFO_CALIBBIAS:						//偏移量
  220. 		switch (chan->channel2)
  221. 		{
  222. 		case IIO_MOD_X:
  223. 			*val=(int)adxl345_read_reg(dev,OFSX);
  224. 			return IIO_VAL_INT;
  225. 			break;
  226. 		case IIO_MOD_Y:
  227. 			*val=(int)adxl345_read_reg(dev,OFSY);
  228. 			return IIO_VAL_INT;
  229. 			break;
  230. 		case IIO_MOD_Z:
  231. 			*val=(int)adxl345_read_reg(dev,OFSZ);
  232. 			return IIO_VAL_INT;
  233. 			break;
  234. 		default:
  235. 			break;
  236. 		}
  237. 		break;
  238. 	case  IIO_CHAN_INFO_FREQUENCY:
  239. 		*val=accel_frequency_adxl345[adxl345_read_reg(dev,BW_RATE)];
  240. 		return IIO_VAL_INT;
  241. 		break;
  242. 	default:
  243. 		break;
  244. 	}
  245. 	return 0;
  246. }
  247.  /*
  248. *   @description : 写函数，向 sysfs 中的文件写数据的时候最终此函数会
  249.                 执行，一般在此函数里面设置传感器，比如量程等。
  250. * @param - indio_dev : iio_dev
  251. * @param - chan : 通道
  252. * @param - val : 读取的值，如果是小数值的话，val 是整数部分。
  253. * @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
  254. * @param - mask : 掩码。
  255. */
  256. static int adxl345_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
  257.  int val, int val2, long mask)
  258. {
  259. 	struct adxl345_dev *dev = iio_priv(indio_dev);
  260. 	int ret = 0;
  261. 	int i=0;
  262. 	switch (mask){
  263. 	case IIO_CHAN_INFO_SCALE:
  264. 		for(i=0;i<ARRAY_SIZE(accel_scale_adxl345);i++){
  265. 			if(accel_scale_adxl345[i]==val2){
  266. 				switch (i){
  267. 				case 0:
  268. 					adxl345_write_reg(dev,DATA_FORMAT ,0X08);
  269. 					break;
  270. 				case 1:
  271. 					adxl345_write_reg(dev,DATA_FORMAT ,0X09);
  272. 					break;
  273. 				case 2:
  274. 					adxl345_write_reg(dev,DATA_FORMAT ,0X0A);
  275. 					break;
  276. 				case 3:
  277. 					adxl345_write_reg(dev,DATA_FORMAT ,0X0B);	
  278. 					break;
  279. 				default:
  280. 					break;
  281. 				}
  282. 			}
  283. 		}
  284. 		break;
  285. 	case IIO_CHAN_INFO_CALIBBIAS:
  286. 		break;
  287. 	case  IIO_CHAN_INFO_FREQUENCY:
  288. 		for(i=0;i<ARRAY_SIZE(accel_frequency_adxl345);i++){
  289. 			if (accel_frequency_adxl345[i]==val){
  290. 					adxl345_write_reg(dev,BW_RATE,i);
  291. 					mdelay(50);		// 等待更新
  292. 			}
  293. 		}
  294. 		break;
  295. 	default:
  296. 		ret = -EINVAL;
  297. 		break;
  298. 	}
  299. 	return ret;
  300. }
  301. /*
  302.  * @description : 用户空间写数据格式，比如我们在用户空间操作 sysfs 来设置传
  303.  * ：感器的分辨率，如果分辨率带小数，那么这个小数传递到内核空间
  304.  * : 应该扩大多少倍，此函数就是用来设置这个的。
  305.  * @param - indio_dev : iio_dev
  306.  * @param - chan : 通道
  307.  * @param - mask : 掩码
  308.  */
  309. static int adxl345_write_raw_get_fmt(struct iio_dev *indio_dev,
  310. 				 struct iio_chan_spec const *chan, long mask)
  311. {
  312. 	switch (mask) {
  313. 	case IIO_CHAN_INFO_SCALE:			/* 用户空间写的加速度计分辨率数据要乘以1000000000 */
  314. 		return IIO_VAL_INT_PLUS_NANO;
  315. 		break;
  316. 	case IIO_CHAN_INFO_CALIBBIAS:
  317. 			return IIO_VAL_INT_PLUS_NANO;
  318. 		// return IIO_VAL_INT;			    //这个宏会报错
  319. 		break;
  320. 	case  IIO_CHAN_INFO_FREQUENCY:
  321. 		return IIO_VAL_INT_PLUS_NANO;
  322. 		// return IIO_VAL_INT;			
  323. 		break;
  324. 	}
  325. 	return -EINVAL;
  326. }
  327. /*
  328.  * iio_info结构体变量
  329.  */
  330. static const struct iio_info adxl345_info = 
  331. {
  332. 	.read_raw		= 		adxl345_read_raw,
  333. 	.write_raw		= 		adxl345_write_raw,
  334. 	.write_raw_get_fmt =    &adxl345_write_raw_get_fmt,
  335. };
  336. /**
  337.  * @description: adxl345寄存器初始化函数
  338.  * @return {*}
  339.  */
  340. static int adxl345reg_init(struct adxl345_dev *dev)
  341. {
  342. 	u8 value;
  343. 	/* 初始化adxl345*/
  344. 	adxl345_write_reg(dev,INTENABLE,0X00);			//使能中断
  345. 	adxl345_write_reg(dev,DATA_FORMAT ,0X0B);		//+-16g	中断高电平有效
  346. 	adxl345_write_reg(dev,BW_RATE,0XF);				//输出速率
  347. 	adxl345_write_reg(dev,POWER_CTL,0X08);			
  348. 	adxl345_write_reg(dev,OFSX,0X00);
  349. 	adxl345_write_reg(dev,OFSY,0X00);
  350. 	adxl345_write_reg(dev,OFSZ,0X00);
  351. 	// 中断配置
  352. 	adxl345_write_reg(dev,INT_MAP,0X02);
  353. 	adxl345_write_reg(dev,FIFO_CTL,0X9F);	
  354. 	adxl345_write_reg(dev,INTENABLE,0X83);								//使能中断
  355. 	value=(unsigned char)adxl345_read_reg(dev,DEVICEID);
  356. 	printk("device id=%#x\r\n",value);
  357. 	mdelay(5);
  358. 	return 0;
  359. }
  360. /*中断下半步处理函数*/
  361. void adxl345_irqwork_func(struct work_struct *work)
  362. {
  363. 	__be16 d ;
  364. 	int i;
  365. 	struct adxl345_dev *dev=container_of(work,struct adxl345_dev,adxl345_irq_work);
  366. 		if(adxl345_read_reg(dev,INT_SORCE)&0X02){
  367. 				mutex_lock(&dev->lock);
  368. 				if(X_Y_Z_FLAG==0){
  369. 					for(i=0;i<DATA_SIZE;i++) {
  370. 					adxl345_read_regs(dev,DATAX0,(u8*)&d,2);
  371. 					BUF_DATA_X_Y_Z[i]=(short)d;
  372. 				}
  373. 				}
  374. 				else if(X_Y_Z_FLAG==1){
  375. 					for(i=0;i<DATA_SIZE;i++) {
  376. 					adxl345_read_regs(dev,DATAY0,(u8*)&d,2);
  377. 					BUF_DATA_X_Y_Z[i]=(short)d;
  378. 				}
  379. 				}
  380. 				else if(X_Y_Z_FLAG==2){
  381. 					for(i=0;i<DATA_SIZE;i++) {
  382. 					adxl345_read_regs(dev,DATAZ0,(u8*)&d,2);
  383. 					BUF_DATA_X_Y_Z[i]=(short)d;
  384. 				}
  385. 				}
  386. 				mutex_unlock(&dev->lock);
  387. 	}
  388. 	if(interrupt_conter%100==0)
  389. 		printk("this is interuupt_%d\n",interrupt_conter);
  390. 	interrupt_conter++;
  391. 	kill_fasync(&dev->async_queue,SIGIO,POLL_IN);
  392. 	adxl345_read_reg(dev,INT_SORCE);                // 清除中断标志位
  393. }
  394. /*adxl345中断使能与关闭*/
  395. static void interrupt_enbale(struct adxl345_dev *dev,bool this_flag)
  396. {
  397. 	mutex_lock(&dev->lock);
  398. 	if(this_flag){
  399. 	adxl345_write_reg(dev,INTENABLE,0X00);	
  400. 	adxl345_write_reg(dev,INT_MAP,0X02);
  401. 	adxl345_write_reg(dev,FIFO_CTL,0X9F);	
  402. 	adxl345_write_reg(dev,INTENABLE,0X83);
  403. 	}
  404. 	else
  405. 		adxl345_write_reg(dev,INTENABLE,0X00);	
  406. 	mutex_unlock(&dev->lock);
  407. }
  408. /*使用工作队列处理下半部*/
  409. static irqreturn_t adxl345_handler(int irq, void *p)
  410. {	struct iio_dev *in_dev=(struct iio_dev*) p;
  411. 	struct adxl345_dev *dev=iio_priv(in_dev); 
  412. 	schedule_work(&dev->adxl345_irq_work);
  413. 	return IRQ_RETVAL(IRQ_HANDLED);
  414. }
  415. /*打开设备，然后打开中断*/
  416. static int adxl345_open(struct inode *inode, struct file *filp)
  417. {
  418. 	struct adxl345_dev *dev;
  419. 	filp->private_data = myprivate_data;
  420. 	dev =(struct adxl345_dev *)filp->private_data;
  421. 	interrupt_enbale(dev,true);
  422. 	return 0;
  423. }
  424. /*fasync函数，用于处理异步通知*/
  425. static int adxl345_fasync(int fd, struct file *filp, int on)
  426. {
  427. 	struct adxl345_dev *dev =(struct adxl345_dev *)filp->private_data;
  428.  	return fasync_helper(fd, filp, on, &dev->async_queue);
  429. }
  430. /*数据读取*/
  431. static ssize_t adxl345_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
  432. {
  433. 	int err=0;
  434. 	struct adxl345_dev *dev =(struct adxl345_dev *)filp->private_data;
  435. 	interrupt_enbale(dev,false);
  436. 	mutex_lock(&dev->lock);
  437. 	err=copy_to_user(buf,BUF_DATA_X_Y_Z,sizeof(BUF_DATA_X_Y_Z));	
  438. 	mutex_unlock(&dev->lock);
  439. 	interrupt_enbale(dev,true);
  440. 	if(err==0)
  441. 		return DATA_SIZE;
  442. 	else
  443. 		return -1;
  444. }
  445. /*数据写入*/
  446. /*应该重新定义write函数的读写格式，buf[0]为寄存器的地址，buf[1]为要写入的值*/
  447. static ssize_t adxl345_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  448. {
  449. 	int retvalue=0;
  450. 	unsigned char databuf[1];
  451. 	struct adxl345_dev *dev =(struct adxl345_dev *)filp->private_data;
  452. 	retvalue = copy_from_user(databuf, buf, cnt);
  453. 	if(retvalue < 0) {
  454. 		printk(KERN_ERR"kernel write failed!\n");
  455. 		return -EFAULT;
  456. 	}
  457. 	mutex_lock(&dev->lock);
  458. 	X_Y_Z_FLAG=databuf[0];
  459. 	mutex_unlock(&dev->lock);
  460. 	return retvalue;
  461. }
  462.  
  463. static int adxl345_release(struct inode *inode, struct file *filp)
  464.  {
  465.  	struct adxl345_dev *dev =(struct adxl345_dev *)filp->private_data;
  466.  	interrupt_enbale(dev,false);
  467. 	return  adxl345_fasync(-1, filp, 0);
  468. }
  469. /* adxl345操作函数 */
  470. static const struct file_operations adxl345_ops = 
  471. {
  472. 	.owner = THIS_MODULE,
  473. 	.open = adxl345_open,
  474. 	.read = adxl345_read,
  475. 	.release = adxl345_release,
  476. 	.write	=adxl345_write,
  477. 	.fasync =adxl345_fasync,
  478. };
  479.  
  480. static int adxl345_probe(struct i2c_client *client, const struct i2c_device_id *id)
  481. {
  482. 	int ret;
  483. 	struct  adxl345_dev  *dev;
  484. 	struct iio_dev *indio_dev;
  485. 	/*  1、申请iio_dev内存 */
  486. 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev));//使用 iio_device_alloc 函数来申请 iio_dev，并且一起申请了 adxl345_dev 的内存。
  487. 	if (!indio_dev)
  488. 		return -ENOMEM;
  489. 	/* 2、获取adxl345_dev结构体地址 */
  490. 	dev = iio_priv(indio_dev); 
  491. 	myprivate_data=dev;
  492. 	dev->client = client;
  493. 	i2c_set_clientdata(client, indio_dev);		 /* 保存indio_dev */
  494. 	mutex_init(&dev->lock);	
  495. 	/*注册设备*/
  496. 	/* 1、构建设备号 */
  497. 	dev->major=0;
  498. 	ret=alloc_chrdev_region(&dev->devid, 0, ADXL345_CNT, ADXL345_NAME);
  499. 	dev->major = MAJOR(dev->devid);
  500. 	if(ret<0)	printk(KERN_ERR"adxl345 chardev err!\n");
  501. 	printk("adxl345 major=%d,minor=%d\n",dev->major,MINOR(dev->devid));
  502. 	/* 2、注册设备 */
  503. 	dev->cdev.owner=THIS_MODULE;
  504. 	cdev_init(&dev->cdev, &adxl345_ops);
  505. 	ret=cdev_add(&dev->cdev, dev->devid, ADXL345_CNT);
  506. 	if(ret<0)	printk(KERN_ERR"adxl345 cedvadd err!\n");
  507. 	/* 3、创建类 */
  508. 	dev->class = class_create(THIS_MODULE, ADXL345_NAME);
  509. 	if (IS_ERR(dev->class)) {
  510. 		printk(KERN_ERR"adxl345 class creat failed!\n");
  511. 		return PTR_ERR(dev->class);
  512. 	}
  513. 	/* 4、创建设备 */
  514. 	dev->device = device_create(dev->class, NULL, dev->devid, NULL, ADXL345_NAME);
  515. 	if (IS_ERR(dev->device)) 
  516.         return PTR_ERR(dev->device);
  517. 	/*申请中断*/
  518. 	// 初始化gpio
  519. 	dev->nd=of_find_node_by_path("/soc/aips-bus@02100000/i2c@021a0000/adxl345@53");
  520. 	 if (dev->nd== NULL)
  521.  		        printk(KERN_INFO"adxl345interrupt-gpios node not find!\n");
  522. 	dev->gpio=of_get_named_gpio(dev->nd,"adxl345_interrupt_gpios",0);
  523. 	if(dev->gpio<0)
  524. 		printk(KERN_INFO"can't get  gpio\n");
  525. 	/* 初始化 IO，并且设置成中断模式 */
  526. 	gpio_request(dev->gpio,ADXL345_INTERRUPT_NAME);
  527. 	gpio_direction_input(dev->gpio);
  528. 	dev->irqnum=irq_of_parse_and_map(dev->nd,0);
  529. 	printk("adxl345_gpio=[%d],irq_num=[%d]\n",dev->gpio,dev->irqnum);
  530. 	dev->handler=adxl345_handler;
  531. 	ret=request_irq(dev->irqnum,dev->handler,IRQF_TRIGGER_RISING,ADXL345_INTERRUPT_NAME,indio_dev);	
  532. 	if(ret < 0)
  533.  		printk(KERN_INFO"irq %d request failed!\n",dev->irqnum);
  534. 	/* 初始化 work */
  535. 	INIT_WORK(&dev->adxl345_irq_work,adxl345_irqwork_func);
  536. 	/* 3、iio_dev的其他成员变量 */
  537. 	indio_dev->dev.parent = &client->dev;
  538. 	indio_dev->info = &adxl345_info;
  539. 	indio_dev->name = ADXL345_NAME;
  540. 	indio_dev->modes = INDIO_DIRECT_MODE;	/* 直接模式，提供sysfs接口 */
  541. 	indio_dev->channels = adxl345_channels;
  542. 	indio_dev->num_channels =ARRAY_SIZE(adxl345_channels);
  543. 	indio_dev->available_scan_masks = adxl345_scan_masks;
  544. 	/* 4、注册iio_dev */
  545. 	ret = iio_device_register(indio_dev);
  546. 	if (ret < 0) {
  547. 		dev_err(&client->dev, "iio_device_register failed\n");
  548. 		return ret;
  549. 	}
  550. 	adxl345reg_init(dev);
  551. 	interrupt_enbale(dev,false);
  552. 	return 0;
  553. }
  554. static int adxl345_remove(struct i2c_client *client)
  555. {
  556. 	struct iio_dev *indio_dev = i2c_get_clientdata(client);
  557. 	struct adxl345_dev *dev=iio_priv(indio_dev);
  558. 	/* 删除设备 */
  559. 	cdev_del(&dev->cdev);
  560. 	unregister_chrdev_region(dev->devid, ADXL345_CNT);
  561. 	/* 注销掉类和设备 */
  562. 	device_destroy(dev->class, dev->devid);
  563. 	class_destroy(dev->class);
  564. 	free_irq(dev->irqnum,indio_dev);
  565. 	/*注销IIO */
  566. 	iio_device_unregister(indio_dev);
  567. 	return 0;
  568. }
  569. /* 传统匹配方式ID列表 */
  570. static const struct i2c_device_id adxl345_id[] = {
  571. 	{"adxl345", 0},  
  572. 	{}
  573. };
  574. /* 设备树匹配列表 */
  575. static const struct of_device_id adxl345_of_match[] = {
  576. 	{ .compatible = "adxl345" },
  577. 	{ /* Sentinel */ }
  578. };
  579. /* i2c驱动结构体 */	
  580. static struct i2c_driver adxl345_driver = {
  581. 	.probe = adxl345_probe,
  582. 	.remove = adxl345_remove,
  583. 	.driver = {
  584. 			.owner = THIS_MODULE,
  585. 		   	.name = "adxl345_driver",
  586. 		   	.of_match_table = adxl345_of_match, 
  587. 		   },
  588. 	.id_table = adxl345_id,
  589. };	   
  590.  
  591. static int __init adxl345_init(void)
  592. {
  593. 	int ret = 0;
  594. 	ret = i2c_add_driver(&adxl345_driver);
  595. 	return ret;
  596. }
  597. static void __exit adxl345_exit(void)
  598. {
  599. 	i2c_del_driver(&adxl345_driver);
  600. }
  601. module_init(adxl345_init);
  602. module_exit(adxl345_exit);
  603. MODULE_LICENSE("GPL");
  604. MODULE_AUTHOR("ZHW-SYSTEAM-FAULT");
  605. MODULE_INFO(intree, "Y");
  606.

1.2 应用层数据读取

         应用层采用Qt 多线程同步处理异步通知信号，因为线程共享信号屏蔽字，主线程在创建子线程后，调用该函数，屏蔽信号，主线程只做界面绘制工作,空闲的子线程拿到信号就进行数据的读取。

  1. void pthread_myset()
  2. {
  3.     int n;
  4.     sigset_t set, oldset;
  5.     sigemptyset(&set);
  6.     sigemptyset(&oldset);
  7.     sigaddset(&set, SIGIO);
  8.     n= pthread_sigmask(SIG_BLOCK,&set, &oldset);
  9.     if(n==0) qDebug()<<"pthread success! "<< endl;
  10. }

 1.2.1 打开文件

  1. void open_adxl345()
  2. {
  3.     int flags = 0;
  4.     char const *filename="/dev/adxl345";
  5.     adxl345_fd=open(filename, O_RDWR);
  6.     if(adxl345_fd < 0){
  7.         return ;
  8.     }
  9.     adxl345_fd_flag=1;                            /*打开文件标志 */
  10.     signal(SIGIO, sigio_signal_func);
  11.     fcntl(adxl345_fd,__F_SETOWN, getpid()); 	 /*将当前进程的进程号告内核*/
  12.     flags = fcntl(adxl345_fd, F_GETFD); 		 /*获取当前的进程状态*/
  13.     fcntl(adxl345_fd, F_SETFL, flags | 00020000); /*设置进程启用异步通知功能*/
  14.     // 设置输出轴
  15.     write(adxl345_fd,direction_buf,sizeof(direction_buf));
  16. }

1.2.2 数据读取

        数据读取利用queqe容器：

  1. void sigio_signal_func(int signum)
  2. {
  3.     int retvalue;
  4.      retvalue= read(adxl345_fd,data,sizeof(data));
  5.      if(retvalue<0)
  6.           qDebug()<<"read's retvalue:"<<retvalue<<endl;
  7.      for(int i=0;i<32;i++)
  8.           queue_data.push(data[i]);    //入队操作
  9.    }

子线程轮询处理数据：

  1. void deal_data_class::working(bool flag){
  2.     this->is_can_run=flag;
  3.     if(!this->is_can_run)
  4.         return ;
  5.     short st_tamp;
  6.     double de_tamp;
  7.     while(this->is_can_run){ 
  8.         if((queue_data.size()>32)){                 // 默认有32个数据才开始出队
  9.             st_tamp=queue_data.front();
  10.             queue_data.pop();
  11.             de_tamp=double(st_tamp*scale_select*9.8);
  12.             
  13.              x_all_count+=x_step;                    // 绘图横坐标累加
  14.             _y.push_back(de_tamp);                   
  15.             _x.push_back(double(x_all_count));
  16.             data_net[read_count]=st_tamp;            
  17.             
  18.             read_count_plot++;
  19.             read_count++;
  20.             
  21.             if(read_count_plot%32==0){
  22.                 //  赋值给plot数组以绘图
  23.                 time_data_and_x_lock.lock();
  24.                 size_32_time_data.clear();
  25.                 size_32_time_x.clear();
  26.                 size_32_time_data=_y;
  27.                 size_32_time_x=_x;
  28.                 time_data_and_x_lock.unlock();
  29.                 emit this->data_can_plot();
  30.                 _x.clear();
  31.                 _y.clear();
  32.             }
  33.             if(read_count%1024==0){
  34.                 //   qDebug()<< read_count_plot<<":readcount"<<endl;
  35.                 if(network_status==1){                      //网络数据数组复制
  36.                     memcpy(send_data_net.data(),&data_net,sizeof(data_net));
  37.                     net_flag=true;              // 数据准备完善标志
  38.                 }
  39.                 read_count=0;
  40.             }
  41.         }
  42.         else {
  43.             QThread::sleep(1);continue;
  44.         }
  45.     }
  46. }

1.3 文件打开与关闭

  1. void read_data_class::working(bool flag)
  2. {
  3.     if(flag){
  4.         if(adxl345_fd_flag==-1 || adxl345_fd_flag==0){
  5.             open_adxl345();
  6.         }
  7.     }
  8.     else{
  9.         // 关闭文件描述符与关闭异步通知
  10.         if(adxl345_fd_flag==1){
  11.               close_adxl345();
  12.           }
  13.     }
  14. }

1.4 绘图

        绘图用的是customplot,qt的qchart在数据量大的情况下就会特别卡顿。

1.5 数据发送

        数据发送由主线层将套接字传递给子线程，由子线程发送。

2 上位机数据处理

2.1 离线数据系统

        主要用于数据分割，后期处理，包括自定义的傅里叶变换长度，局部、全局数据分析。

2.2 在线监测系统

2.2.1 模型训练与模型加载

模型训练使用的pytorch框架，其数据预处理、模型构建，以及示范的LSTM1DCNN网络模型与作者该篇博客类似：基于LSTM的故障诊断_基于lstm的轴承故障检测_旧日之歌的博客-CSDN博客。

模型的推理从pth模型保存为pt模型：

  1. import torch.nn.functional as F
  2. from torchvision import transforms
  3. from matplotlib import pyplot as plt
  4. from numpy import dtype
  5. from 数据划分 import *
  6. import torchvision
  7. from torch import nn, Tensor
  8. from torch.nn import Conv1d,MaxPool1d,Flatten,Linear
  9. import torch
  10. device = torch.device("cpu")
  11. class mylstm(nn.Module):
  12.     def __init__(self):
  13.         super(mylstm, self).__init__()
  14.         self.modle1 = nn.LSTM(input_size=1,hidden_size=16,num_layers=2, batch_first=True,dropout=0.2)
  15.         self.modle2 = nn.Sequential (
  16.                         nn.Conv1d(512,128,1,1),
  17.                         nn.MaxPool1d(2,2),
  18.                         nn.Conv1d(128,32,4,4),
  19.                         nn.Flatten(),
  20.                         nn.Linear(64, 32),
  21.                         nn.Dropout(0.1),
  22.                         nn.ReLU(),
  23.                         nn.Linear(32,4 ),
  24.         )
  25.     def forward(self, x):
  26.         h_0 = torch.randn(2,128,16)
  27.         c_0 = torch.randn(2,128, 16)
  28.         h_0 = h_0.to(device)
  29.         c_0 = c_0.to(device)
  30.         x = x.to(torch.float32)
  31.         x,(h_0,c_0)=self.modle1(x,(h_0,c_0))
  32.         x=self.modle2(x)
  33.         return x
  34. from LSTM_1DCNN import *
  35. model=mylstm()
  36. state_dict=torch.load("libtorchtest_dict_practice_200.pth")
  37. model.load_state_dict(state_dict)
  38. model.to(device)
  39. model.eval()
  40. x=torch.randn(128,cut_long,1).to(device)
  41. traced_script_module = torch.jit.trace(model, x)
  42. traced_script_module.save('libtorchtest_dict_practice_200.pt')#保存模型位置
  43. print("save is ok\n")
  44. mymodel=torch.jit.load('libtorchtest_dict_practice_200.pt')
  45. output=mymodel(x)
  46. print(output)

2.2.2 模型的部署

        模型的部署主要采用的是libtorch框架，如何将libtorch框架移植在QT里可搜索网上其他教程，但一般要注意以下几个点:

  1. 1、-INCLUDE:?searchsorted_cuda@native@at@@YA?AVTensor@2@AEBV32@0_N1@Z -INCLUDE:?warp_size@cuda@at@@YAHXZ     一定要在qt链接动态的时候加上这串字符
  2. 2、一定要注意libtorch和pytorch的版本问题，两者要完全对应，推理用的是cuda，那么部署能用cpu/cuda,如果推理用cpu，部署只能用cpu。
  3. 3、环境变量

2.2.3 模型加载与使用

        

  1. //model_load 模型加载或者使用    model_select 选择模型  use_gpu gpu使用选择
  2. void model_load::working(bool model_load,const std::string module_path_, int model_select,bool use_gpu)
  3. {
  4.     if(model_load){  // 模型加载
  5.         this->module_path=module_path_;
  6.         if(model_select==1){        // 加载lstm——1dcnn模型
  7.             if(this->model_count[model_select]==1){
  8.                 emit this->to_log_print("lstm1dcnn已加载");
  9.                 return;
  10.             }
  11.             if (torch::cuda::is_available())
  12.                     emit this->to_log_print("支持GPU");
  13.             if (torch::cuda::is_available() && use_gpu){
  14.                 this->device_=torch::kCUDA;
  15.                 emit this->to_log_print("the module for lstm1dcnn use cuda...");
  16.             }
  17.             else{
  18.                 emit this->to_log_print("the module  for lstm1dcnn use cpu...");
  19.                 this->device_ = torch::kCPU;
  20.             }
  21.             try {
  22.                 this->module_lstm1dcnn=torch::jit::load(this->module_path);
  23.                 emit this->to_log_print("the module for lstm1dcnn load successed...");
  24.             }
  25.             catch (const c10::Error& e) {
  26.                 std::cerr << "Error loading the model!\n";
  27.                 emit this->to_log_print("the module for lstm1dcnn load failed...");
  28.             }
  29.             this->module_lstm1dcnn.to(this->device_);
  30.             this->module_lstm1dcnn.eval();                
  31.             this->model_count[1]=1;                     // 模型lstm1dcnn加载标志
  32.         }
  33.     }
  34.  
  35.     else{                                               // 模型识别
  36.         QString module_name;
  37.         if (torch::cuda::is_available() && use_gpu){
  38.             this->device_=torch::kCUDA;
  39.             emit this->to_log_print("the module is using cuda...");
  40.         }
  41.         else{
  42.             emit this->to_log_print("the module is using cpu...");
  43.             this->device_ = torch::kCPU;
  44.         }
  45.       at::TensorOptions ops=at::TensorOptions().dtype(at::kDouble).device(this->device_);
  46.         if(model_select==1 && this->model_count[1]==1){
  47.              this->module_lstm1dcnn.to(this->device_);
  48.             online_data.model_diagnosis_lock.lockForRead();
  49.             data_scaler(online_data.model_diagnosis);   //数据归一化
  50.             this->input_tensor=torch::from_blob(online_data.model_diagnosis.data()
  51.                                             , {128,512,1},ops).to(this->device_).clone();   // 深度拷贝
  52.             online_data.model_diagnosis_lock.unlock();
  53.             this->output=this->module_lstm1dcnn.forward(std::vector<torch::jit::IValue>{this->input_tensor}).toTensor();
  54.             emit this->to_log_print("the module of lstm1dcnn'identify  is OK...");
  55.             module_name="LSTM1DCNN";
  56.             // 结果输出
  57.             at::Tensor outputarg= this->output.argmax(1);
  58.             int output_result[4];
  59.             memset(output_result,0,sizeof(output_result));
  60.             for(int i=0;i<128;i++)
  61.                 output_result[outputarg[i].item().toInt()]++;
  62.             emit this->diagnosis_result(output_result[0],output_result[1],output_result[2],output_result[3]);
  63.             int max_result=0;
  64.             int max_index=0;
  65.             //  记录最大结果以及结果汇总
  66.             for(int i=0;i<4;i++){
  67.                 emit this->to_log_print(QString("当前%1诊断结果统计：%2").arg(i).arg(output_result[i]));
  68.                 if(output_result[i]>max_result){
  69.                     max_result=output_result[i];
  70.                     max_index=i;
  71.                 }
  72.             }
  73.             // 发送给tabelwidget
  74.             QDateTime Timedata = QDateTime::currentDateTime();               //  获取当前时间
  75.             QString str = Timedata.toString("yyyy-MM-dd-hh:mm:ss");
  76.             emit this->to_tablewidget("NULL",                               // 序号
  77.                                       str,                                  // 时间
  78.                                       module_name,                          //模型
  79.                                       online_data.direction_sample,        // 采样轴
  80.                                       QString("%1[%2/128]").arg(label_fault[max_index]).arg(max_result),// 诊断结果
  81.                                       QString("%1Hz").arg(online_data.hz_for_select));      //采样频率
  82.         }
  83.         }
  84. //        else{
  85. //            emit this->to_log_print("the module of lstm1dcnn  unloaded......");
  86. //            return  ;
  87. //        }
  88. //        if(model_select==2 && this->model_count[1]==2){
  89. //            // restnet模型识别
  90. //        }
  91. //        else{
  92. //            return ;
  93. //        }
  94. //        if(model_select==3 && this->model_count[3]==3){
  95. //            // cnn模型识别
  96. //        }
  97. //        else{
  98. //            return ;
  99. //        }
  100.  
  101. }

2.2.4 傅里叶变换

        傅里叶变换采用的是fftw库，号称是世界上最快的傅里叶变换。测试结果与matlab所输出的结果一致。

  1. void fft_function(vector<double>& after_fft_data,vector<double> before_fft_data,int fft_length)
  2. {
  3.     fftw_complex  *out;
  4.     fftw_complex *in;
  5.     fftw_plan p;
  6.     in =(fftw_complex*)fftw_malloc(sizeof(fftw_complex) * fft_length);
  7.     out=(fftw_complex*)fftw_malloc(sizeof(fftw_complex) * fft_length);
  8.     p=fftw_plan_dft_1d(fft_length,in,out,FFTW_FORWARD,FFTW_ESTIMATE);
  9.     for(int i=0;i<fft_length;i++){
  10.        in[i][0]=before_fft_data.at(i);
  11.        in[i][1]=0;
  12.     }
  13.     fftw_execute(p);
  14.     after_fft_data.clear();
  15.      after_fft_data.push_back(0);                                   // 去除直流分量
  16.     for(int j=1;j<fft_length/2+1;j++){
  17.        after_fft_data.push_back(sqrt(out[j][0]*out[j][0]+out[j][1]*out[j][1])/fft_length*2);
  18.     }
  19.   
  20.     fftw_destroy_plan(p);
  21.     if(in!=NULL)
  22.     {
  23.        fftw_free(in);
  24.     }
  25.     if(out!=NULL){
  26.         fftw_free(out);
  27.     }
  28. }

2.2.5 网络数据读取

  1. void Online_data_analysis::network_set_init()
  2. {
  3.     // 创建通信的套接字
  4.     this->m_tcp =new QTcpSocket(this);
  5.     connect(this->m_tcp,&QTcpSocket::readyRead,this,[=](){
  6.         // qDebug()<<"it can ready"<<endl;
  7.         QByteArray array = this->m_tcp->readAll();
  8.         if(array.size()==(sizeof(short)*1024)){                         // 读取的数据
  9.             short* p=(short*)array.data();
  10.             online_data.fft_and_datapara_lock.lockForWrite();
  11.             for(int i=0;i<1024;i++)
  12.                 online_data.fft_and_datapara.push_back((online_data.scale_sample*(double)p[i]*9.8));    
  13.             online_data.fft_and_datapara_lock.unlock();
  14.             online_data.net_read_count++;
  15.             //发送给fft时域状态参数计算变换等子线程
  16.             this->fft_and_data_deal_thread->working();
  17.             ui->output_log_plainTextEdit->appendPlainText(QString("从网络中读取次数为(2048字节/次)：%1......").arg(online_data.net_read_count));
  18.         }
  19.         if(array.size()==5){    // 读取的初始化信息
  20.             unsigned char *p= (unsigned char*)array.data();
  21.             // online_data_struct online_dat在此函数内部初始化
  22.             // 每检测到初始化信息，所有数据都重新清除
  23.             ui->output_log_plainTextEdit->appendPlainText("状态重置>>>......");
  24.             this->parameter_show_of_come_net(p[0],p[1],p[2],p[3],p[4]);
  25.         }
  26.     });
  27.     // 服务器端断开连接
  28.     connect(this->m_tcp,&QTcpSocket::disconnected ,this,[=](){
  29.         ui->server_ip_lineEdit->setText("服务器连接已断开....");
  30.         ui->server_port_lineEdit->setText("服务器连接已断开....");
  31.         this->information_print_net_flag(0,"服务器连接已断开....");
  32.         this->m_tcp->close();
  33.         ui->pushButton_net_start->setDisabled(false);
  34.         ui->pushButton_net_end->setDisabled(true);
  35.         qDebug()<<"the net is disconnected"<<endl;
  36.     });
  37.     // 检测连接
  38.     connect(this->m_tcp,&QTcpSocket::connected ,this,[=](){
  39.         // 显示服务器IP和端口
  40.         ui->server_ip_lineEdit->setText(this->m_tcp->peerAddress().toString());
  41.         ui->server_port_lineEdit->setText( QString::number(this->m_tcp->peerPort()));
  42.         this->information_print_net_flag(1,"已连接服务器....");
  43.         ui->pushButton_net_start->setDisabled(true);
  44.         ui->pushButton_net_end->setDisabled(false);
  45.         QString str="the connect is init for client ,if recieved,server's read is ok";
  46.         this->m_tcp->write(str.toUtf8().data());
  47.     });
  48. }

2.2.6 其他

        频域折线图、柱状图、监测数据显示（导入与导出）、数据保存、界面状态参数更新等。

3 总结

        该系统还存在许多不足之处与改进之处，最开始只想做个数据实时绘制界面，就没考windows端的上位机，导致许多数据处理逻辑都还在下位机，这对下位机的性能是个挑战，最好是把所有数据处理逻辑全都移交给上位机，下位机只做数据读取和发送。

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

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

  

闽ICP备14008679号