设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 全网首发SCD40二氧化碳传感器源程序
返回列表 发新帖
查看: 3380|回复: 8
收起左侧

全网首发SCD40二氧化碳传感器源程序

  [复制链接]
ID:397211 发表于 2022-1-11 16:56 | 显示全部楼层 |阅读模式
本程序芯片为STM32F103C8T6，使用HAL库，通过官方的库GITHUP移植而来，源代码可以到GITHUP中搜索SCD40。
此模块因为有速度要求，每5秒刷新一次数据，所以都懂的。
0.png

单片机源程序如下:
  1. #include "scd4x_i2c.h"
  2. #include "sensirion_common.h"
  3. #include "sensirion_i2c.h"
  4. #include "sensirion_i2c_hal.h"

  6. #define SCD4X_I2C_ADDRESS 98

  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);

  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. }

  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);

  29.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  30.     if (error) {
  31.         return error;
  32.     }

  34. //    sensirion_i2c_hal_sleep_usec(1000);

  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. }

  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);

  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. //}

  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);

  85.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  86.     if (error) {
  87.         return error;
  88.     }

  90.     sensirion_i2c_hal_sleep_usec(1000);

  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. }

  100. int16_t scd4x_get_temperature_offset(int32_t* t_offset_m_deg_c) {
  101.     int16_t error;
  102.     uint16_t t_offset;

  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. }

  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);

  118.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset, t_offset);

  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. }

  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. }

  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);

  139.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  140.     if (error) {
  141.         return error;
  142.     }

  144.     sensirion_i2c_hal_sleep_usec(1000);

  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. }

  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);

  160.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
  161.                                                   sensor_altitude);

  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. }

  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);

  177.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
  178.                                                   ambient_pressure);

  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. }

  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);

  195.     offset = sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset,
  196.                                                   target_co2_concentration);

  198.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  199.     if (error) {
  200.         return error;
  201.     }

  203.     sensirion_i2c_hal_sleep_usec(400000);

  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. }

  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);

  219.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  220.     if (error) {
  221.         return error;
  222.     }

  224.     sensirion_i2c_hal_sleep_usec(1000);

  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. }

  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);

  240.     offset =
  241.         sensirion_i2c_add_uint16_t_to_buffer(&buffer[0], offset, asc_enabled);

  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. }

  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);

  256.     return sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  257. }

  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);

  265.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  266.     if (error) {
  267.         return error;
  268.     }

  270.     sensirion_i2c_hal_sleep_usec(1000);

  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. }

  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);

  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. }

  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);

  301.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  302.     if (error) {
  303.         return error;
  304.     }

  306.     sensirion_i2c_hal_sleep_usec(1000);

  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. }

  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);

  324.     error = sensirion_i2c_write_data(SCD4X_I2C_ADDRESS, &buffer[0], offset);
  325.     if (error) {
  326.         return error;
  327.     }

  329.     sensirion_i2c_hal_sleep_usec(10000000);

  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. }

  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);

  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. }

  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);

  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. }

  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);

  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. }

  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);

  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. }


复制代码
51hei.png
以上11个文件下载,请自行加入到您的工程中:
SCD4xco2.zip (24.32 KB, 下载次数: 120)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:1023701 发表于 2022-5-4 13:06 | 显示全部楼层
你的最终数据变量是哪一个啊 可不可以给一下main.c的代码 求求了
回复

使用道具 举报

ID:1024381 发表于 2022-5-6 18:50 | 显示全部楼层
谢谢，正需要，调试。官方Git下载的运行不正常
回复

使用道具 举报

ID:397211 发表于 2022-6-2 17:04 | 显示全部楼层
北道无辙 发表于 2022-5-4 13:06
你的最终数据变量是哪一个啊 可不可以给一下main.c的代码 求求了

我这个是官方移植的
回复

使用道具 举报

ID:397211 发表于 2022-6-2 17:05 | 显示全部楼层
ws51dhy 发表于 2022-5-6 18:50
谢谢，正需要，调试。官方Git下载的运行不正常

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

使用道具 举报

ID:667696 发表于 2022-9-28 16:28 | 显示全部楼层
谢谢，正需要，调试
回复

使用道具 举报

ID:667696 发表于 2022-10-10 11:46 | 显示全部楼层
上面SCD的MAIN.c有吗？能不能一起发出来一下
回复

使用道具 举报

ID:272926 发表于 2023-8-18 14:12 | 显示全部楼层
拿官方的代码有什么意义？ CO2的值都是1000多，哪个能准吗
回复

使用道具 举报

ID:162723 发表于 2023-10-25 17:54 | 显示全部楼层
谢谢，正好需要，官方的例子调了一下午没调通
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表