【瑞萨RRH62000-EVK套件】剩余RRH62000传感器驱动添加

oxlm

   RRH62000支持的传感器驱动很多，上一次仅仅是添加完了温度传感器，这次将剩余的rrh62000传感器接口添加上去。下面是传感器支持的功能列表。

  相对应的，rtthread目前支持的传感器列表如下：

1. #define RT_SENSOR_CLASS_GYRO           (2)  /* Gyroscope         */
   
2. #define RT_SENSOR_CLASS_MAG            (3)  /* Magnetometer      */
   
3. #define RT_SENSOR_CLASS_TEMP           (4)  /* Temperature       */
   
4. #define RT_SENSOR_CLASS_HUMI           (5)  /* Relative Humidity */
   
5. #define RT_SENSOR_CLASS_BARO           (6)  /* Barometer         */
   
6. #define RT_SENSOR_CLASS_LIGHT          (7)  /* Ambient light     */
   
7. #define RT_SENSOR_CLASS_PROXIMITY      (8)  /* Proximity         */
   
8. #define RT_SENSOR_CLASS_HR             (9)  /* Heart Rate        */
   
9. #define RT_SENSOR_CLASS_TVOC           (10) /* TVOC Level        */
   
10. #define RT_SENSOR_CLASS_NOISE          (11) /* Noise Loudness    */
    
11. #define RT_SENSOR_CLASS_STEP           (12) /* Step sensor       */
    
12. #define RT_SENSOR_CLASS_FORCE          (13) /* Force sensor      */
    
13. #define RT_SENSOR_CLASS_DUST           (14) /* Dust sensor       */
    
14. #define RT_SENSOR_CLASS_ECO2           (15) /* eCO2 sensor       */
    
15. #define RT_SENSOR_CLASS_GNSS           (16) /* GPS/GNSS sensor   */
    
16. #define RT_SENSOR_CLASS_TOF            (17) /* TOF sensor        */
    
17. #define RT_SENSOR_CLASS_SPO2           (18) /* SpO2 sensor       */
    
18. #define RT_SENSOR_CLASS_IAQ            (19) /* IAQ sensor.       */
    
19. #define RT_SENSOR_CLASS_ETOH           (20) /* EtOH sensor.      */
    
20. #define RT_SENSOR_CLASS_BP             (21) /* Blood Pressure    */

复制代码

  从这里面看，如果不动RTT的传感器支持列表（不往里面新增），在不考虑功能重复的情况下，RRH62000至少可以添加6种传感器。除去之前添加的温度传感器，还能添加的有，灰尘传感器（规格书中提到的PMxxx，NCxxx总共9种），湿度传感器，总挥发性有机化合物传感器，二氧化碳传感器，空气质量传感器。
  由于开源项目部分暂时不适合动中间框架层的代码，因此灰尘传感器部分就只上报一个参数上去，若有需求，内部项目在框架层添加传感器种类并在驱动层将剩余功能添加上。
代码修改
  前面已经贴过所有的部分了，这里仅仅贴修改的部分。
drv_rrh62000.c
  代码修改其实就一个套路，增加一种传感器的注册，并在读数据接口中根据传感器种类上报对应数据。由于传感器框架存在我一直认为不合理的地方，就是如果传感器是以模组形式存在，那目前的传感器框架分别读传感器内容时，就会出现每次读都要跑去运行一遍总线的情况。这极大地增加了系统地开销。

1. static rt_ssize_t _get_data(rt_sensor_t sensor, struct rt_sensor_data *data)
   
2. {
   
3.     struct sensor_device *dev = sensor->parent.user_data;
   
4.     rt_bool_t isDataReady = RT_FALSE;
   
5. 
   
6.     switch(sensor->info.type)
   
7.     {
   
8.     case RT_SENSOR_CLASS_TEMP:
   
9.     case RT_SENSOR_CLASS_HUMI:
   
10.     case RT_SENSOR_CLASS_TVOC:
    
11.     case RT_SENSOR_CLASS_ECO2:
    
12.     case RT_SENSOR_CLASS_IAQ:
    
13.     case RT_SENSOR_CLASS_DUST:
    
14.         if((rrh62000_read_data_status(dev->dev, &isDataReady) == RT_EOK) && (isDataReady))
    
15.         {
    
16.             rrh62000_read_measured_value(dev->dev, &dev->data);
    
17.         }
    
18.         break;
    
19.     default:
    
20.         return 0;
    
21.     }
    
22. 
    
23.     switch(sensor->info.type)
    
24.     {
    
25.     case RT_SENSOR_CLASS_TEMP:
    
26.         data->data.temp = (dev->data.temperature.integer_part << 16) + dev->data.temperature.decimal_part;
    
27.         break;
    
28.         
    
29.     case RT_SENSOR_CLASS_HUMI:
    
30.         data->data.temp = (dev->data.humidity.integer_part << 16) + dev->data.humidity.decimal_part;
    
31.         break;
    
32. 
    
33.     case RT_SENSOR_CLASS_TVOC:
    
34.         data->data.temp = (dev->data.tvoc.integer_part << 16) + dev->data.tvoc.decimal_part;
    
35.         break;
    
36. 
    
37.     case RT_SENSOR_CLASS_ECO2:
    
38.         data->data.temp = (dev->data.eco2.integer_part << 16) + dev->data.eco2.decimal_part;
    
39.         break;
    
40. 
    
41.     case RT_SENSOR_CLASS_IAQ:
    
42.         data->data.temp = (dev->data.iaq.integer_part << 16) + dev->data.iaq.decimal_part;
    
43.         break;
    
44. 
    
45.     case RT_SENSOR_CLASS_DUST:
    
46.         data->data.temp = (dev->data.nc_2p5.integer_part << 16) + dev->data.nc_2p5.decimal_part;
    
47.         break;
    
48. 
    
49.     default:
    
50.         goto RET;
    
51.         break;
    
52.     }
    
53. 
    
54.     data->timestamp = rt_sensor_get_ts();
    
55.     return 1;
    
56. 
    
57. RET:
    
58.     return 0;
    
59. }
    
60. 
    
61. #ifdef BSP_USING_RRH62000_TEMP
    
62. rt_err_t rrh62000_register_temperature(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
    
63. {
    
64.     rt_sensor_t sensor = RT_NULL;
    
65.     rt_int8_t result;
    
66. 
    
67.     /* sensor register */
    
68.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
    
69.     if (sensor == RT_NULL)
    
70.         goto __exit;
    
71.    
    
72.     sensor->info.type       = RT_SENSOR_CLASS_TEMP; // Set real type
    
73.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
    
74.     sensor->info.model      = name;  // set real model name
    
75.     sensor->info.unit       = RT_SENSOR_UNIT_DCELSIUS; // set to real unit flag
    
76.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
    
77.     sensor->info.range_max  = 0xFFFF; // Set to range max
    
78.     sensor->info.range_min  = 0x0000; // Set to range min
    
79.     sensor->info.period_min = 50; // Set frequency
    
80. 
    
81.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
    
82.     sensor->ops = &sensor_ops;
    
83. 
    
84.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
    
85.     if (result != RT_EOK)
    
86.     {
    
87.         goto __exit;
    
88.     }
    
89. 
    
90.     return RT_EOK;
    
91. 
    
92. __exit:
    
93.     if (sensor)
    
94.         rt_free(sensor);
    
95. 
    
96.     return -RT_ERROR;
    
97. }
    
98. #endif
    
99. 
    
100. #ifdef BSP_USING_RRH62000_HUMI
     
101. rt_err_t rrh62000_register_humidity(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
     
102. {
     
103.     rt_sensor_t sensor = RT_NULL;
     
104.     rt_int8_t result;
     
105. 
     
106.     /* sensor register */
     
107.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
     
108.     if (sensor == RT_NULL)
     
109.         goto __exit;
     
110.    
     
111.     sensor->info.type       = RT_SENSOR_CLASS_HUMI; // Set real type
     
112.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
     
113.     sensor->info.model      = name;  // set real model name
     
114.     sensor->info.unit       = RT_SENSOR_UNIT_PERMILLAGE; // set to real unit flag
     
115.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
     
116.     sensor->info.range_max  = 0xFFFF; // Set to range max
     
117.     sensor->info.range_min  = 0x0000; // Set to range min
     
118.     sensor->info.period_min = 50; // Set frequency
     
119. 
     
120.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
     
121.     sensor->ops = &sensor_ops;
     
122. 
     
123.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
     
124.     if (result != RT_EOK)
     
125.     {
     
126.         goto __exit;
     
127.     }
     
128. 
     
129.     return RT_EOK;
     
130. 
     
131. __exit:
     
132.     if (sensor)
     
133.         rt_free(sensor);
     
134. 
     
135.     return -RT_ERROR;
     
136. }
     
137. #endif
     
138. 
     
139. #ifdef BSP_USING_RRH62000_TVOC
     
140. rt_err_t rrh62000_register_TVOC(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
     
141. {
     
142.     rt_sensor_t sensor = RT_NULL;
     
143.     rt_int8_t result;
     
144. 
     
145.     /* sensor register */
     
146.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
     
147.     if (sensor == RT_NULL)
     
148.         goto __exit;
     
149.    
     
150.     sensor->info.type       = RT_SENSOR_CLASS_TVOC; // Set real type
     
151.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
     
152.     sensor->info.model      = name;  // set real model name
     
153.     sensor->info.unit       = RT_SENSOR_UNIT_MGM3; // set to real unit flag
     
154.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
     
155.     sensor->info.range_max  = 0xFFFF; // Set to range max
     
156.     sensor->info.range_min  = 0x0000; // Set to range min
     
157.     sensor->info.period_min = 50; // Set frequency
     
158. 
     
159.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
     
160.     sensor->ops = &sensor_ops;
     
161. 
     
162.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
     
163.     if (result != RT_EOK)
     
164.     {
     
165.         goto __exit;
     
166.     }
     
167. 
     
168.     return RT_EOK;
     
169. 
     
170. __exit:
     
171.     if (sensor)
     
172.         rt_free(sensor);
     
173. 
     
174.     return -RT_ERROR;
     
175. }
     
176. #endif
     
177. 
     
178. #ifdef BSP_USING_RRH62000_DUST
     
179. rt_err_t rrh62000_register_Dust(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
     
180. {
     
181.     rt_sensor_t sensor = RT_NULL;
     
182.     rt_int8_t result;
     
183. 
     
184.     /* sensor register */
     
185.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
     
186.     if (sensor == RT_NULL)
     
187.         goto __exit;
     
188.    
     
189.     sensor->info.type       = RT_SENSOR_CLASS_DUST; // Set real type
     
190.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
     
191.     sensor->info.model      = name;  // set real model name
     
192.     sensor->info.unit       = RT_SENSOR_UNIT_MGM3; // set to real unit flag
     
193.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
     
194.     sensor->info.range_max  = 0xFFFF; // Set to range max
     
195.     sensor->info.range_min  = 0x0000; // Set to range min
     
196.     sensor->info.period_min = 50; // Set frequency
     
197. 
     
198.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
     
199.     sensor->ops = &sensor_ops;
     
200. 
     
201.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
     
202.     if (result != RT_EOK)
     
203.     {
     
204.         goto __exit;
     
205.     }
     
206. 
     
207.     return RT_EOK;
     
208. 
     
209. __exit:
     
210.     if (sensor)
     
211.         rt_free(sensor);
     
212. 
     
213.     return -RT_ERROR;
     
214. }
     
215. #endif
     
216. 
     
217. #ifdef BSP_USING_RRH62000_ECO2
     
218. rt_err_t rrh62000_register_ECO2(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
     
219. {
     
220.     rt_sensor_t sensor = RT_NULL;
     
221.     rt_int8_t result;
     
222. 
     
223.     /* sensor register */
     
224.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
     
225.     if (sensor == RT_NULL)
     
226.         goto __exit;
     
227.    
     
228.     sensor->info.type       = RT_SENSOR_CLASS_ECO2; // Set real type
     
229.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
     
230.     sensor->info.model      = name;  // set real model name
     
231.     sensor->info.unit       = RT_SENSOR_UNIT_PPM; // set to real unit flag
     
232.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
     
233.     sensor->info.range_max  = 0xFFFF; // Set to range max
     
234.     sensor->info.range_min  = 0x0000; // Set to range min
     
235.     sensor->info.period_min = 50; // Set frequency
     
236. 
     
237.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
     
238.     sensor->ops = &sensor_ops;
     
239. 
     
240.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
     
241.     if (result != RT_EOK)
     
242.     {
     
243.         goto __exit;
     
244.     }
     
245. 
     
246.     return RT_EOK;
     
247. 
     
248. __exit:
     
249.     if (sensor)
     
250.         rt_free(sensor);
     
251. 
     
252.     return -RT_ERROR;
     
253. }
     
254. #endif
     
255. 
     
256. #ifdef BSP_USING_RRH62000_IAQ
     
257. rt_err_t rrh62000_register_IAQ(const char *name, struct rt_sensor_config *cfg, struct sensor_device *dev)
     
258. {
     
259.     rt_sensor_t sensor = RT_NULL;
     
260.     rt_int8_t result;
     
261. 
     
262.     /* sensor register */
     
263.     sensor = rt_calloc(1, sizeof(struct rt_sensor_device));
     
264.     if (sensor == RT_NULL)
     
265.         goto __exit;
     
266.    
     
267.     sensor->info.type       = RT_SENSOR_CLASS_IAQ; // Set real type
     
268.     sensor->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN; // Set real vendor
     
269.     sensor->info.model      = name;  // set real model name
     
270.     sensor->info.unit       = RT_SENSOR_UNIT_NONE; // set to real unit flag
     
271.     sensor->info.intf_type  = RT_SENSOR_INTF_I2C; // Set interface type
     
272.     sensor->info.range_max  = 0xFFFF; // Set to range max
     
273.     sensor->info.range_min  = 0x0000; // Set to range min
     
274.     sensor->info.period_min = 50; // Set frequency
     
275. 
     
276.     rt_memcpy(&sensor->config, cfg, sizeof(struct rt_sensor_config));
     
277.     sensor->ops = &sensor_ops;
     
278. 
     
279.     result = rt_hw_sensor_register(sensor, name, RT_DEVICE_FLAG_RDONLY, dev);
     
280.     if (result != RT_EOK)
     
281.     {
     
282.         goto __exit;
     
283.     }
     
284. 
     
285.     return RT_EOK;
     
286. 
     
287. __exit:
     
288.     if (sensor)
     
289.         rt_free(sensor);
     
290. 
     
291.     return -RT_ERROR;
     
292. }
     
293. #endif
     
294. 
     
295. static int rrh62000_device_register(void)
     
296. {
     
297.     rt_int8_t result;
     
298.     struct sensor_device *dev;
     
299.     const char *name = "rrh62000";
     
300.     struct rt_sensor_config      cfg = {
     
301.         .mode = RT_SENSOR_MODE_POLLING,
     
302.         .power = RT_SENSOR_POWER_DOWN,
     
303.     };
     
304. 
     
305.     dev = rrh62000_param_init();
     
306.     if(dev == RT_NULL)
     
307.     {
     
308.         goto __exit;
     
309.     }
     
310. 
     
311. #ifdef BSP_USING_RRH62000_TEMP
     
312.     result = rrh62000_register_temperature(name, &cfg, dev);
     
313.     if (result != RT_EOK)
     
314.     {
     
315.         goto __exit;
     
316.     }
     
317. #endif
     
318. 
     
319. #ifdef BSP_USING_RRH62000_HUMI
     
320.     result = rrh62000_register_humidity(name, &cfg, dev);
     
321.     if (result != RT_EOK)
     
322.     {
     
323.         goto __exit;
     
324.     }
     
325. #endif
     
326. 
     
327. #ifdef BSP_USING_RRH62000_TVOC
     
328.     result = rrh62000_register_TVOC(name, &cfg, dev);
     
329.     if (result != RT_EOK)
     
330.     {
     
331.         goto __exit;
     
332.     }
     
333. #endif
     
334. 
     
335. #ifdef BSP_USING_RRH62000_DUST
     
336.     result = rrh62000_register_Dust(name, &cfg, dev);
     
337.     if (result != RT_EOK)
     
338.     {
     
339.         goto __exit;
     
340.     }
     
341. #endif
     
342. 
     
343. #ifdef BSP_USING_RRH62000_ECO2
     
344.     result = rrh62000_register_ECO2(name, &cfg, dev);
     
345.     if (result != RT_EOK)
     
346.     {
     
347.         goto __exit;
     
348.     }
     
349. #endif
     
350. 
     
351. #ifdef BSP_USING_RRH62000_IAQ
     
352.     result = rrh62000_register_IAQ(name, &cfg, dev);
     
353.     if (result != RT_EOK)
     
354.     {
     
355.         goto __exit;
     
356.     }
     
357. #endif
     
358. 
     
359.     return RT_EOK;
     
360. 
     
361. __exit:
     
362.     if(dev)
     
363.         rt_free(dev);
     
364.     return -RT_ERROR;
     
365. }
     
366. INIT_DEVICE_EXPORT(rrh62000_device_register);
     
367. 
     
368. #ifdef BSP_USING_RRH62000_TEMP
     
369. #define RRH_TEMP_DEVICE_NAME "temp_rrh"
     
370. static void rrh6200_temp_read(void)
     
371. {
     
372.     rt_device_t dev = rt_device_find(RRH_TEMP_DEVICE_NAME);
     
373.     rt_err_t result;
     
374.     rt_uint32_t len;
     
375.     struct rt_sensor_data data;
     
376. 
     
377.     if(!dev)
     
378.     {
     
379.         rt_kprintf("No device name %s\n\r", RRH_TEMP_DEVICE_NAME);
     
380.         return;
     
381.     }
     
382.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
383.     if(result != RT_EOK)
     
384.     {
     
385.         rt_kprintf("Open %s Fail\n\r", RRH_TEMP_DEVICE_NAME);
     
386.         return;
     
387.     }
     
388.    
     
389.     len = rt_device_read(dev, 0 ,&data,1);
     
390.     if(len)
     
391.     {
     
392.         rt_kprintf("Temp %d.%d \n\r", data.data.temp >> 16, data.data.temp & 0x0000FFFF);
     
393.     }
     
394. 
     
395.     result = rt_device_close(dev);
     
396.     if(result != RT_EOK)
     
397.     {
     
398.         rt_kprintf("Close %s Fail\n\r", RRH_TEMP_DEVICE_NAME);
     
399.         return;
     
400.     }
     
401. }
     
402. MSH_CMD_EXPORT(rrh6200_temp_read, rrh62000 sample);
     
403. #endif
     
404. 
     
405. 
     
406. #ifdef BSP_USING_RRH62000_HUMI
     
407. #define RRH_HUMI_DEVICE_NAME "humi_rrh"
     
408. static void rrh6200_humi_read(void)
     
409. {
     
410.     rt_device_t dev = rt_device_find(RRH_HUMI_DEVICE_NAME);
     
411.     rt_err_t result;
     
412.     rt_uint32_t len;
     
413.     struct rt_sensor_data data;
     
414. 
     
415.     if(!dev)
     
416.     {
     
417.         rt_kprintf("No device name %s\n\r", RRH_HUMI_DEVICE_NAME);
     
418.         return;
     
419.     }
     
420.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
421.     if(result != RT_EOK)
     
422.     {
     
423.         rt_kprintf("Open %s Fail\n\r", RRH_HUMI_DEVICE_NAME);
     
424.         return;
     
425.     }
     
426.    
     
427.     len = rt_device_read(dev, 0 ,&data,1);
     
428.     if(len)
     
429.     {
     
430.         rt_kprintf("Humidity %d.%d \n\r", data.data.humi >> 16, data.data.humi & 0x0000FFFF);
     
431.     }
     
432. 
     
433.     result = rt_device_close(dev);
     
434.     if(result != RT_EOK)
     
435.     {
     
436.         rt_kprintf("Close %s Fail\n\r", RRH_HUMI_DEVICE_NAME);
     
437.         return;
     
438.     }
     
439. }
     
440. MSH_CMD_EXPORT(rrh6200_humi_read, rrh62000 sample);
     
441. #endif
     
442. 
     
443. #ifdef BSP_USING_RRH62000_TVOC
     
444. #define RRH_TVOC_DEVICE_NAME "tvoc_rrh"
     
445. static void rrh6200_tvoc_read(void)
     
446. {
     
447.     rt_device_t dev = rt_device_find(RRH_TVOC_DEVICE_NAME);
     
448.     rt_err_t result;
     
449.     rt_uint32_t len;
     
450.     struct rt_sensor_data data;
     
451. 
     
452.     if(!dev)
     
453.     {
     
454.         rt_kprintf("No device name %s\n\r", RRH_TVOC_DEVICE_NAME);
     
455.         return;
     
456.     }
     
457.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
458.     if(result != RT_EOK)
     
459.     {
     
460.         rt_kprintf("Open %s Fail\n\r", RRH_TVOC_DEVICE_NAME);
     
461.         return;
     
462.     }
     
463.    
     
464.     len = rt_device_read(dev, 0 ,&data,1);
     
465.     if(len)
     
466.     {
     
467.         rt_kprintf("TVOC %d.%d \n\r", data.data.tvoc >> 16, data.data.tvoc & 0x0000FFFF);
     
468.     }
     
469. 
     
470.     result = rt_device_close(dev);
     
471.     if(result != RT_EOK)
     
472.     {
     
473.         rt_kprintf("Close %s Fail\n\r", RRH_TVOC_DEVICE_NAME);
     
474.         return;
     
475.     }
     
476. }
     
477. MSH_CMD_EXPORT(rrh6200_tvoc_read, rrh62000 sample);
     
478. #endif
     
479. 
     
480. #ifdef BSP_USING_RRH62000_DUST
     
481. #define RRH_DUST_DEVICE_NAME "dust_rrh"
     
482. static void rrh6200_dust_read(void)
     
483. {
     
484.     rt_device_t dev = rt_device_find(RRH_DUST_DEVICE_NAME);
     
485.     rt_err_t result;
     
486.     rt_uint32_t len;
     
487.     struct rt_sensor_data data;
     
488. 
     
489.     if(!dev)
     
490.     {
     
491.         rt_kprintf("No device name %s\n\r", RRH_DUST_DEVICE_NAME);
     
492.         return;
     
493.     }
     
494.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
495.     if(result != RT_EOK)
     
496.     {
     
497.         rt_kprintf("Open %s Fail\n\r", RRH_DUST_DEVICE_NAME);
     
498.         return;
     
499.     }
     
500.    
     
501.     len = rt_device_read(dev, 0 ,&data,1);
     
502.     if(len)
     
503.     {
     
504.         rt_kprintf("dust %d.%d \n\r", data.data.dust >> 16, data.data.dust & 0x0000FFFF);
     
505.     }
     
506. 
     
507.     result = rt_device_close(dev);
     
508.     if(result != RT_EOK)
     
509.     {
     
510.         rt_kprintf("Close %s Fail\n\r", RRH_DUST_DEVICE_NAME);
     
511.         return;
     
512.     }
     
513. }
     
514. MSH_CMD_EXPORT(rrh6200_dust_read, rrh62000 sample);
     
515. #endif
     
516. 
     
517. #ifdef BSP_USING_RRH62000_ECO2
     
518. #define RRH_ECO2_DEVICE_NAME "eco2_rrh"
     
519. static void rrh6200_eco2_read(void)
     
520. {
     
521.     rt_device_t dev = rt_device_find(RRH_ECO2_DEVICE_NAME);
     
522.     rt_err_t result;
     
523.     rt_uint32_t len;
     
524.     struct rt_sensor_data data;
     
525. 
     
526.     if(!dev)
     
527.     {
     
528.         rt_kprintf("No device name %s\n\r", RRH_ECO2_DEVICE_NAME);
     
529.         return;
     
530.     }
     
531.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
532.     if(result != RT_EOK)
     
533.     {
     
534.         rt_kprintf("Open %s Fail\n\r", RRH_ECO2_DEVICE_NAME);
     
535.         return;
     
536.     }
     
537.    
     
538.     len = rt_device_read(dev, 0 ,&data,1);
     
539.     if(len)
     
540.     {
     
541.         rt_kprintf("ECO2 %d.%d \n\r", data.data.eco2 >> 16, data.data.eco2 & 0x0000FFFF);
     
542.     }
     
543. 
     
544.     result = rt_device_close(dev);
     
545.     if(result != RT_EOK)
     
546.     {
     
547.         rt_kprintf("Close %s Fail\n\r", RRH_ECO2_DEVICE_NAME);
     
548.         return;
     
549.     }
     
550. }
     
551. MSH_CMD_EXPORT(rrh6200_eco2_read, rrh62000 sample);
     
552. #endif
     
553. 
     
554. 
     
555. #ifdef BSP_USING_RRH62000_IAQ
     
556. #define RRH_IAQ_DEVICE_NAME "iaq_rrh6"
     
557. static void rrh6200_iaq_read(void)
     
558. {
     
559.     rt_device_t dev = rt_device_find(RRH_IAQ_DEVICE_NAME);
     
560.     rt_err_t result;
     
561.     rt_uint32_t len;
     
562.     struct rt_sensor_data data;
     
563. 
     
564.     if(!dev)
     
565.     {
     
566.         rt_kprintf("No device name %s\n\r", RRH_IAQ_DEVICE_NAME);
     
567.         return;
     
568.     }
     
569.     result = rt_device_open(dev,RT_DEVICE_FLAG_RDONLY);
     
570.     if(result != RT_EOK)
     
571.     {
     
572.         rt_kprintf("Open %s Fail\n\r", RRH_IAQ_DEVICE_NAME);
     
573.         return;
     
574.     }
     
575.    
     
576.     len = rt_device_read(dev, 0 ,&data,1);
     
577.     if(len)
     
578.     {
     
579.         rt_kprintf("IAQ %d.%d \n\r", data.data.iaq >> 16, data.data.iaq & 0x0000FFFF);
     
580.     }
     
581. 
     
582.     result = rt_device_close(dev);
     
583.     if(result != RT_EOK)
     
584.     {
     
585.         rt_kprintf("Close %s Fail\n\r", RRH_IAQ_DEVICE_NAME);
     
586.         return;
     
587.     }
     
588. }
     
589. MSH_CMD_EXPORT(rrh6200_iaq_read, rrh62000 sample);
     
590. #endif

复制代码

KConfig

1.     menu "Board extended module Drivers"
   
2.         menuconfig BSP_USING_RRH62000
   
3.         bool "Enable RRH62000"
   
4.         default n
   
5.         if BSP_USING_RRH62000
   
6.             config BSP_USING_RRH62000_TEMP
   
7.                 bool "Enable RRH62000 Temperature"
   
8.                     default n
   
9. 
   
10.             config BSP_USING_RRH62000_HUMI
    
11.                 bool "Enable RRH62000 Humidity"
    
12.                     default n
    
13. 
    
14.             config BSP_USING_RRH62000_TVOC
    
15.                 bool "Enable RRH62000 TVOC"
    
16.                     default n
    
17. 
    
18.             config BSP_USING_RRH62000_ECO2
    
19.                 bool "Enable RRH62000 ECO2"
    
20.                     default n
    
21. 
    
22.             config BSP_USING_RRH62000_DUST
    
23.                 bool "Enable RRH62000 Dust"
    
24.                     default n
    
25. 
    
26.             config BSP_USING_RRH62000_IAQ
    
27.                 bool "Enable RRH62000 IAQ"
    
28.                     default n
    
29.         endif
    
30. 
    
31.     endmenu

复制代码

  以上部分修改完后，需运行menuconfig选配好对应的传感器功能并运行scons --target=mdk5生成新工程。我的测试环境是将所有传感器功能都启用。
运行结果

1. \ | /
   
2. - RT -     Thread Operating System
   
3. / | \     5.2.0 build Nov 30 2024 20:07:57
   
4. 2006 - 2024 Copyright by RT-Thread team
   
5. [I/I2C] I2C bus [i2c1] registered
   
6. rrh62000 firmware version 1.0
   
7. rrh62000 algoritm version 3.2.0
   
8. [I/sensor] rt_sensor[temp_rrh62000] init success
   
9. [I/sensor] rt_sensor[humi_rrh62000] init success
   
10. [I/sensor] rt_sensor[tvoc_rrh62000] init success
    
11. [I/sensor] rt_sensor[dust_rrh62000] init success
    
12. [I/sensor] rt_sensor[eco2_rrh62000] init success
    
13. [I/sensor] rt_sensor[iaq_rrh62000] init success
    
14. 
    
15. Hello RT-Thread!
    
16. msh >rrh6200_iaq_read
    
17. IAQ 0.0
    
18. msh >rrh6200_iaq_read
    
19. IAQ 1.0
    
20. msh >rrh6200_eco2_read
    
21. ECO2 400.0
    
22. msh >rrh6200_dust_read
    
23. dust 0.1
    
24. msh >rrh6200_tvoc_read
    
25. TVOC 0.2
    
26. msh >rrh6200_temp_read
    
27. Temp 21.85
    
28. msh >rrh6200_humi_read
    
29. Humidity 41.75
    
30. msh >

复制代码