标题: 全网首发SCD40二氧化碳传感器源程序 [打印本页]

---

作者: 保持微笑    时间: 2022-1-11 16:56
标题: 全网首发SCD40二氧化碳传感器源程序
本程序芯片为STM32F103C8T6，使用HAL库，通过官方的库GITHUP移植而来，源代码可以到GITHUP中搜索SCD40。
此模块因为有速度要求，每5秒刷新一次数据，所以都懂的。


单片机源程序如下:

1. #include "scd4x_i2c.h"
   
2. #include "sensirion_common.h"
   
3. #include "sensirion_i2c.h"
   
4. #include "sensirion_i2c_hal.h"
   
5. 
   
6. #define SCD4X_I2C_ADDRESS 98
   
7. 
   
8. int16_t scd4x_start_periodic_measurement() {
   
9.     int16_t error;
   
10.     uint8_t buffer[2];
    
11.     uint16_t offset = 0;
    
12.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x21B1);
    
13. 
    
14.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
    
15.     if (error) {
    
16.         return error;
    
17.     }
    
18.     sensirion_i2c_hal_sleep_usec(1000);
    
19.     return NO_ERROR;
    
20. }
    
21. 
    
22. int16_t scd4x_read_measurement_ticks(uint16_t* co2, uint16_t* temperature,
    
23.                                      uint16_t* humidity) {
    
24.     int16_t error;
    
25.     uint8_t buffer[9];
    
26.     uint16_t offset = 0;
    
27.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0xEC05);
    
28. 
    
29.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
    
30.     if (error) {
    
31.         return error;
    
32.     }
    
33. 
    
34. //    sensirion_i2c_hal_sleep_usec(1000);
    
35. 
    
36.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 6);
    
37.     if (error) {
    
38.         return error;
    
39.     }
    
40.     *co2 = sensirion_common_bytes_to_uint16_t(&buffer[0]);
    
41.     *temperature = sensirion_common_bytes_to_uint16_t(&buffer[2]);
    
42.     *humidity = sensirion_common_bytes_to_uint16_t(&buffer[4]);
    
43.     return NO_ERROR;
    
44. }
    
45. //需要5秒才能再次调用，传感器的响应时间为5秒
    
46. int16_t scd4x_read_measurement(uint16_t* co2, int32_t* temperature_m_deg_c,
    
47.                                int32_t* humidity_m_percent_rh) {
    
48.     int16_t error;
    
49.     uint16_t temperature;
    
50.     uint16_t humidity;
    
51.     error = scd4x_read_measurement_ticks(co2, &temperature, &humidity);
    
52.     if (error) {
    
53.         return error;
    
54.     }
    
55. #if 1
    
56.     *temperature_m_deg_c = ((21875 * (int32_t)temperature) >> 13) - 45000;
    
57.     *humidity_m_percent_rh = ((12500 * (int32_t)humidity) >> 13);
    
58. #else
    
59.     *temperature_m_deg_c = ((175000 * (int32_t)temperature) >> 15) - 45000;
    
60.     *humidity_m_percent_rh = ((100000 * (int32_t)humidity) >> 15);
    
61. #endif
    
62.     return NO_ERROR;
    
63. }
    
64. 
    
65. //int16_t scd4x_stop_periodic_measurement() {
    
66. //    int16_t error;
    
67. //    uint8_t buffer[2];
    
68. //    uint16_t offset = 0;
    
69. //    offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3F86);
    
70. 
    
71. //    error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
    
72. //    if (error) {
    
73. //        return error;
    
74. //    }
    
75. //    sensirion_i2c_hal_sleep_usec(500000);
    
76. //    return NO_ERROR;
    
77. //}
    
78. 
    
79. int16_t scd4x_get_temperature_offset_ticks(uint16_t* t_offset) {
    
80.     int16_t error;
    
81.     uint8_t buffer[3];
    
82.     uint16_t offset = 0;
    
83.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2318);
    
84. 
    
85.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
    
86.     if (error) {
    
87.         return error;
    
88.     }
    
89. 
    
90.     sensirion_i2c_hal_sleep_usec(1000);
    
91. 
    
92.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
    
93.     if (error) {
    
94.         return error;
    
95.     }
    
96.     *t_offset = sensirion_common_bytes_to_uint16_t(&buffer[0]);
    
97.     return NO_ERROR;
    
98. }
    
99. 
    
100. int16_t scd4x_get_temperature_offset(int32_t* t_offset_m_deg_c) {
     
101.     int16_t error;
     
102.     uint16_t t_offset;
     
103. 
     
104.     error = scd4x_get_temperature_offset_ticks(&t_offset);
     
105.     if (error) {
     
106.         return error;
     
107.     }
     
108.     *t_offset_m_deg_c = ((21875 * (int32_t)t_offset) >> 13);
     
109.     return NO_ERROR;
     
110. }
     
111. 
     
112. int16_t scd4x_set_temperature_offset_ticks(uint16_t t_offset) {
     
113.     int16_t error;
     
114.     uint8_t buffer[5];
     
115.     uint16_t offset = 0;
     
116.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x241D);
     
117. 
     
118.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset, t_offset);
     
119. 
     
120.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
121.     if (error) {
     
122.         return error;
     
123.     }
     
124.     sensirion_i2c_hal_sleep_usec(1000);
     
125.     return NO_ERROR;
     
126. }
     
127. 
     
128. int16_t scd4x_set_temperature_offset(int32_t t_offset_m_deg_c) {
     
129.     uint16_t t_offset = (uint16_t)((t_offset_m_deg_c * 12271) >> 15);
     
130.     return scd4x_set_temperature_offset_ticks(t_offset);
     
131. }
     
132. 
     
133. int16_t scd4x_get_sensor_altitude(uint16_t* sensor_altitude) {
     
134.     int16_t error;
     
135.     uint8_t buffer[3];
     
136.     uint16_t offset = 0;
     
137.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2322);
     
138. 
     
139.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
140.     if (error) {
     
141.         return error;
     
142.     }
     
143. 
     
144.     sensirion_i2c_hal_sleep_usec(1000);
     
145. 
     
146.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
     
147.     if (error) {
     
148.         return error;
     
149.     }
     
150.     *sensor_altitude = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
151.     return NO_ERROR;
     
152. }
     
153. 
     
154. int16_t scd4x_set_sensor_altitude(uint16_t sensor_altitude) {
     
155.     int16_t error;
     
156.     uint8_t buffer[5];
     
157.     uint16_t offset = 0;
     
158.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2427);
     
159. 
     
160.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
     
161.                                                   sensor_altitude);
     
162. 
     
163.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
164.     if (error) {
     
165.         return error;
     
166.     }
     
167.     sensirion_i2c_hal_sleep_usec(1000);
     
168.     return NO_ERROR;
     
169. }
     
170. 
     
171. int16_t scd4x_set_ambient_pressure(uint16_t ambient_pressure) {
     
172.     int16_t error;
     
173.     uint8_t buffer[5];
     
174.     uint16_t offset = 0;
     
175.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0xE000);
     
176. 
     
177.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
     
178.                                                   ambient_pressure);
     
179. 
     
180.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
181.     if (error) {
     
182.         return error;
     
183.     }
     
184.     sensirion_i2c_hal_sleep_usec(1000);
     
185.     return NO_ERROR;
     
186. }
     
187. 
     
188. int16_t scd4x_perform_forced_recalibration(uint16_t target_co2_concentration,
     
189.                                            uint16_t* frc_correction) {
     
190.     int16_t error;
     
191.     uint8_t buffer[5];
     
192.     uint16_t offset = 0;
     
193.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x362F);
     
194. 
     
195.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
     
196.                                                   target_co2_concentration);
     
197. 
     
198.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
199.     if (error) {
     
200.         return error;
     
201.     }
     
202. 
     
203.     sensirion_i2c_hal_sleep_usec(400000);
     
204. 
     
205.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
     
206.     if (error) {
     
207.         return error;
     
208.     }
     
209.     *frc_correction = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
210.     return NO_ERROR;
     
211. }
     
212. 
     
213. int16_t scd4x_get_automatic_self_calibration(uint16_t* asc_enabled) {
     
214.     int16_t error;
     
215.     uint8_t buffer[3];
     
216.     uint16_t offset = 0;
     
217.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2313);
     
218. 
     
219.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
220.     if (error) {
     
221.         return error;
     
222.     }
     
223. 
     
224.     sensirion_i2c_hal_sleep_usec(1000);
     
225. 
     
226.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
     
227.     if (error) {
     
228.         return error;
     
229.     }
     
230.     *asc_enabled = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
231.     return NO_ERROR;
     
232. }
     
233. 
     
234. int16_t scd4x_set_automatic_self_calibration(uint16_t asc_enabled) {
     
235.     int16_t error;
     
236.     uint8_t buffer[5];
     
237.     uint16_t offset = 0;
     
238.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2416);
     
239. 
     
240.     offset =
     
241.         sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset, asc_enabled);
     
242. 
     
243.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
244.     if (error) {
     
245.         return error;
     
246.     }
     
247.     sensirion_i2c_hal_sleep_usec(1000);
     
248.     return NO_ERROR;
     
249. }
     
250. 
     
251. int16_t scd4x_start_low_power_periodic_measurement() {
     
252.     uint8_t buffer[2];
     
253.     uint16_t offset = 0;
     
254.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x21AC);
     
255. 
     
256.     return sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
257. }
     
258. 
     
259. int16_t scd4x_get_data_ready_status(uint16_t* data_ready) {
     
260.     int16_t error;
     
261.     uint8_t buffer[3];
     
262.     uint16_t offset = 0;
     
263.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0xE4B8);
     
264. 
     
265.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
266.     if (error) {
     
267.         return error;
     
268.     }
     
269. 
     
270.     sensirion_i2c_hal_sleep_usec(1000);
     
271. 
     
272.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
     
273.     if (error) {
     
274.         return error;
     
275.     }
     
276.     *data_ready = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
277.     return NO_ERROR;
     
278. }
     
279. 
     
280. int16_t scd4x_persist_settings() {
     
281.     int16_t error;
     
282.     uint8_t buffer[2];
     
283.     uint16_t offset = 0;
     
284.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3615);
     
285. 
     
286.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
287.     if (error) {
     
288.         return error;
     
289.     }
     
290.     sensirion_i2c_hal_sleep_usec(800000);
     
291.     return NO_ERROR;
     
292. }
     
293. 
     
294. int16_t scd4x_get_serial_number(uint16_t* serial_0, uint16_t* serial_1,
     
295.                                 uint16_t* serial_2) {
     
296.     int16_t error;
     
297.     uint8_t buffer[9];
     
298.     uint16_t offset = 0;
     
299.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3682);
     
300. 
     
301.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
302.     if (error) {
     
303.         return error;
     
304.     }
     
305. 
     
306.     sensirion_i2c_hal_sleep_usec(1000);
     
307. 
     
308.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 6);
     
309.     if (error) {
     
310.         return error;
     
311.     }
     
312.     *serial_0 = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
313.     *serial_1 = sensirion_common_bytes_to_uint16_t(&buffer[2]);
     
314.     *serial_2 = sensirion_common_bytes_to_uint16_t(&buffer[4]);
     
315.     return NO_ERROR;
     
316. }
     
317. 
     
318. int16_t scd4x_perform_self_test(uint16_t* sensor_status) {
     
319.     int16_t error;
     
320.     uint8_t buffer[3];
     
321.     uint16_t offset = 0;
     
322.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3639);
     
323. 
     
324.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
325.     if (error) {
     
326.         return error;
     
327.     }
     
328. 
     
329.     sensirion_i2c_hal_sleep_usec(10000000);
     
330. 
     
331.     error = sensirion_i2c_read_data_inplace(SCD4X_I2C_ADDRESS, &buffer[0], 2);
     
332.     if (error) {
     
333.         return error;
     
334.     }
     
335.     *sensor_status = sensirion_common_bytes_to_uint16_t(&buffer[0]);
     
336.     return NO_ERROR;
     
337. }
     
338. 
     
339. int16_t scd4x_perform_factory_reset() {
     
340.     int16_t error;
     
341.     uint8_t buffer[2];
     
342.     uint16_t offset = 0;
     
343.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3632);
     
344. 
     
345.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
346.     if (error) {
     
347.         return error;
     
348.     }
     
349.     sensirion_i2c_hal_sleep_usec(800000);
     
350.     return NO_ERROR;
     
351. }
     
352. 
     
353. int16_t scd4x_reinit() {
     
354.     int16_t error;
     
355.     uint8_t buffer[2];
     
356.     uint16_t offset = 0;
     
357.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x3646);
     
358. 
     
359.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
360.     if (error) {
     
361.         return error;
     
362.     }
     
363.     sensirion_i2c_hal_sleep_usec(20000);
     
364.     return NO_ERROR;
     
365. }
     
366. 
     
367. int16_t scd4x_measure_single_shot() {
     
368.     int16_t error;
     
369.     uint8_t buffer[2];
     
370.     uint16_t offset = 0;
     
371.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x219D);
     
372. 
     
373.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
374.     if (error) {
     
375.         return error;
     
376.     }
     
377.     sensirion_i2c_hal_sleep_usec(5000000);
     
378.     return NO_ERROR;
     
379. }
     
380. 
     
381. int16_t scd4x_measure_single_shot_rht_only() {
     
382.     int16_t error;
     
383.     uint8_t buffer[2];
     
384.     uint16_t offset = 0;
     
385.     offset = sensirion_i2c_add_command_to_buffer(&buffer[0], offset, 0x2196);
     
386. 
     
387.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
     
388.     if (error) {
     
389.         return error;
     
390.     }
     
391.     sensirion_i2c_hal_sleep_usec(50000);
     
392.     return NO_ERROR;
     
393. }
     
394. 
     
395. 
     

复制代码

以上11个文件下载,请自行加入到您的工程中:
SCD4xco2.zip (24.32 KB, 下载次数: 131)

2022-1-11 16:51 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 北道无辙    时间: 2022-5-4 13:06
你的最终数据变量是哪一个啊 可不可以给一下main.c的代码 求求了

---

作者: ws51dhy    时间: 2022-5-6 18:50
谢谢，正需要，调试。官方Git下载的运行不正常

---

作者: 保持微笑    时间: 2022-6-2 17:04

北道无辙 发表于 2022-5-4 13:06
你的最终数据变量是哪一个啊 可不可以给一下main.c的代码 求求了

我这个是官方移植的

---

作者: 保持微笑    时间: 2022-6-2 17:05

ws51dhy 发表于 2022-5-6 18:50
谢谢，正需要，调试。官方Git下载的运行不正常

我这个是叫我们传感器厂商移植的，采样时间在5秒一次才不会出现问题

---

作者: XINGYUN7573    时间: 2022-9-28 16:28
谢谢，正需要，调试

---

作者: XINGYUN7573    时间: 2022-10-10 11:46
上面SCD的MAIN.c有吗？能不能一起发出来一下

---

作者: gonglichuan    时间: 2023-8-18 14:12
拿官方的代码有什么意义？ CO2的值都是1000多，哪个能准吗

---

作者: 兰大明    时间: 2023-10-25 17:54
谢谢，正好需要，官方的例子调了一下午没调通

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1