718 lines
20 KiB
C
718 lines
20 KiB
C
/* USER CODE BEGIN Header */
|
||
/**
|
||
******************************************************************************
|
||
* @file sts_aq_sgp30.c *
|
||
* @author Yunhorn (r) Technology Limited Application Team *
|
||
* @brief Yunhorn (r) SmarToilets (r) Product configuration file. *
|
||
******************************************************************************
|
||
* @attention
|
||
*
|
||
* Copyright (c) 2025 Yunhorn Technology Limited.
|
||
* Copyright (c) 2025 Shenzhen Yunhorn Technology Co., Ltd.
|
||
* All rights reserved.
|
||
*
|
||
* This software is licensed under terms that can be found in the LICENSE file
|
||
* in the root directory of this software component.
|
||
* If no LICENSE file comes with this software, it is provided AS-IS.
|
||
*
|
||
******************************************************************************
|
||
*/
|
||
/* USER CODE END Header */
|
||
|
||
|
||
#include "sgp30.h"
|
||
#include "sensirion_arch_config.h"
|
||
#include "sensirion_common.h"
|
||
#include "sensirion_i2c.h"
|
||
#include "sgp_git_version.h"
|
||
|
||
#define SGP30_PRODUCT_TYPE 0
|
||
static const uint8_t SGP30_I2C_ADDRESS = 0x58;
|
||
|
||
/* command and constants for reading the serial ID */
|
||
#define SGP30_CMD_GET_SERIAL_ID 0x3682
|
||
#define SGP30_CMD_GET_SERIAL_ID_DURATION_US 500
|
||
#define SGP30_CMD_GET_SERIAL_ID_WORDS 3
|
||
|
||
/* command and constants for reading the featureset version */
|
||
#define SGP30_CMD_GET_FEATURESET 0x202f
|
||
#define SGP30_CMD_GET_FEATURESET_DURATION_US 10000
|
||
#define SGP30_CMD_GET_FEATURESET_WORDS 1
|
||
|
||
/* command and constants for on-chip self-test */
|
||
#define SGP30_CMD_MEASURE_TEST 0x2032
|
||
#define SGP30_CMD_MEASURE_TEST_DURATION_US 220000
|
||
#define SGP30_CMD_MEASURE_TEST_WORDS 1
|
||
#define SGP30_CMD_MEASURE_TEST_OK 0xd400
|
||
|
||
/* command and constants for IAQ init */
|
||
#define SGP30_CMD_IAQ_INIT 0x2003
|
||
#define SGP30_CMD_IAQ_INIT_DURATION_US 10000
|
||
|
||
/* command and constants for IAQ measure */
|
||
#define SGP30_CMD_IAQ_MEASURE 0x2008
|
||
#define SGP30_CMD_IAQ_MEASURE_DURATION_US 12000
|
||
#define SGP30_CMD_IAQ_MEASURE_WORDS 2
|
||
|
||
/* command and constants for getting IAQ baseline */
|
||
#define SGP30_CMD_GET_IAQ_BASELINE 0x2015
|
||
#define SGP30_CMD_GET_IAQ_BASELINE_DURATION_US 10000
|
||
#define SGP30_CMD_GET_IAQ_BASELINE_WORDS 2
|
||
|
||
/* command and constants for setting IAQ baseline */
|
||
#define SGP30_CMD_SET_IAQ_BASELINE 0x201e
|
||
#define SGP30_CMD_SET_IAQ_BASELINE_DURATION_US 10000
|
||
|
||
/* command and constants for raw measure */
|
||
#define SGP30_CMD_RAW_MEASURE 0x2050
|
||
#define SGP30_CMD_RAW_MEASURE_DURATION_US 25000
|
||
#define SGP30_CMD_RAW_MEASURE_WORDS 2
|
||
|
||
/* command and constants for setting absolute humidity */
|
||
#define SGP30_CMD_SET_ABSOLUTE_HUMIDITY 0x2061
|
||
#define SGP30_CMD_SET_ABSOLUTE_HUMIDITY_DURATION_US 10000
|
||
|
||
/* command and constants for getting TVOC inceptive baseline */
|
||
#define SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE 0x20b3
|
||
#define SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE_DURATION_US 10000
|
||
#define SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE_WORDS 1
|
||
|
||
/* command and constants for setting TVOC baseline */
|
||
#define SGP30_CMD_SET_TVOC_BASELINE 0x2077
|
||
#define SGP30_CMD_SET_TVOC_BASELINE_DURATION_US 10000
|
||
|
||
/**
|
||
* sgp30_check_featureset() - Check if the connected sensor has a certain FS
|
||
*
|
||
* @needed_fs: The featureset that is required
|
||
*
|
||
* Return: STATUS_OK if the sensor has the required FS,
|
||
* SGP30_ERR_INVALID_PRODUCT_TYPE if the sensor is not an SGP30,
|
||
* SGP30_ERR_UNSUPPORTED_FEATURE_SET if the sensor does not
|
||
* have the required FS,
|
||
* an error code otherwise
|
||
*/
|
||
static int16_t sgp30_check_featureset(uint16_t needed_fs)
|
||
{
|
||
int16_t ret;
|
||
uint16_t fs_version;
|
||
uint8_t product_type;
|
||
|
||
ret = sgp30_get_feature_set_version(&fs_version, &product_type);
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
if (product_type != SGP30_PRODUCT_TYPE)
|
||
return SGP30_ERR_INVALID_PRODUCT_TYPE;
|
||
|
||
if (fs_version < needed_fs)
|
||
return SGP30_ERR_UNSUPPORTED_FEATURE_SET;
|
||
|
||
return STATUS_OK;
|
||
}
|
||
|
||
int16_t sgp30_measure_test(uint16_t *test_result)
|
||
{
|
||
uint16_t measure_test_word_buf[SGP30_CMD_MEASURE_TEST_WORDS];
|
||
int16_t ret;
|
||
|
||
*test_result = 0;
|
||
|
||
ret = sensirion_i2c_delayed_read_cmd(
|
||
SGP30_I2C_ADDRESS, SGP30_CMD_MEASURE_TEST,
|
||
SGP30_CMD_MEASURE_TEST_DURATION_US, measure_test_word_buf,
|
||
SENSIRION_NUM_WORDS(measure_test_word_buf));
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
*test_result = *measure_test_word_buf;
|
||
if (*test_result == SGP30_CMD_MEASURE_TEST_OK)
|
||
return STATUS_OK;
|
||
|
||
return STATUS_FAIL;
|
||
}
|
||
|
||
int16_t sgp30_measure_iaq()
|
||
{
|
||
return sensirion_i2c_write_cmd(SGP30_I2C_ADDRESS, SGP30_CMD_IAQ_MEASURE);
|
||
}
|
||
|
||
int16_t sgp30_read_iaq(uint16_t *tvoc_ppb, uint16_t *co2_eq_ppm)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[SGP30_CMD_IAQ_MEASURE_WORDS];
|
||
|
||
ret = sensirion_i2c_read_words(SGP30_I2C_ADDRESS, words,
|
||
SGP30_CMD_IAQ_MEASURE_WORDS);
|
||
|
||
*tvoc_ppb = words[1];
|
||
*co2_eq_ppm = words[0];
|
||
|
||
return ret;
|
||
}
|
||
|
||
int16_t sgp30_measure_iaq_blocking_read(uint16_t *tvoc_ppb,
|
||
uint16_t *co2_eq_ppm)
|
||
{
|
||
int16_t ret;
|
||
|
||
ret = sgp30_measure_iaq();
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_IAQ_MEASURE_DURATION_US);
|
||
|
||
return sgp30_read_iaq(tvoc_ppb, co2_eq_ppm);
|
||
}
|
||
|
||
int16_t sgp30_measure_tvoc()
|
||
{
|
||
return sgp30_measure_iaq();
|
||
}
|
||
|
||
int16_t sgp30_read_tvoc(uint16_t *tvoc_ppb)
|
||
{
|
||
uint16_t co2_eq_ppm;
|
||
return sgp30_read_iaq(tvoc_ppb, &co2_eq_ppm);
|
||
}
|
||
|
||
int16_t sgp30_measure_tvoc_blocking_read(uint16_t *tvoc_ppb)
|
||
{
|
||
uint16_t co2_eq_ppm;
|
||
return sgp30_measure_iaq_blocking_read(tvoc_ppb, &co2_eq_ppm);
|
||
}
|
||
|
||
int16_t sgp30_measure_co2_eq()
|
||
{
|
||
return sgp30_measure_iaq();
|
||
}
|
||
|
||
int16_t sgp30_read_co2_eq(uint16_t *co2_eq_ppm)
|
||
{
|
||
uint16_t tvoc_ppb;
|
||
return sgp30_read_iaq(&tvoc_ppb, co2_eq_ppm);
|
||
}
|
||
|
||
int16_t sgp30_measure_co2_eq_blocking_read(uint16_t *co2_eq_ppm)
|
||
{
|
||
uint16_t tvoc_ppb;
|
||
return sgp30_measure_iaq_blocking_read(&tvoc_ppb, co2_eq_ppm);
|
||
}
|
||
|
||
int16_t sgp30_measure_raw_blocking_read(uint16_t *ethanol_raw_signal,
|
||
uint16_t *h2_raw_signal)
|
||
{
|
||
int16_t ret;
|
||
|
||
ret = sgp30_measure_raw();
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_RAW_MEASURE_DURATION_US);
|
||
|
||
return sgp30_read_raw(ethanol_raw_signal, h2_raw_signal);
|
||
}
|
||
|
||
int16_t sgp30_measure_raw()
|
||
{
|
||
return sensirion_i2c_write_cmd(SGP30_I2C_ADDRESS, SGP30_CMD_RAW_MEASURE);
|
||
}
|
||
|
||
int16_t sgp30_read_raw(uint16_t *ethanol_raw_signal, uint16_t *h2_raw_signal)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[SGP30_CMD_RAW_MEASURE_WORDS];
|
||
|
||
ret = sensirion_i2c_read_words(SGP30_I2C_ADDRESS, words,
|
||
SGP30_CMD_RAW_MEASURE_WORDS);
|
||
|
||
*ethanol_raw_signal = words[1];
|
||
*h2_raw_signal = words[0];
|
||
|
||
return ret;
|
||
}
|
||
|
||
int16_t sgp30_get_iaq_baseline(uint32_t *baseline)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[SGP30_CMD_GET_IAQ_BASELINE_WORDS];
|
||
|
||
ret =
|
||
sensirion_i2c_write_cmd(SGP30_I2C_ADDRESS, SGP30_CMD_GET_IAQ_BASELINE);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_GET_IAQ_BASELINE_DURATION_US);
|
||
|
||
ret = sensirion_i2c_read_words(SGP30_I2C_ADDRESS, words,
|
||
SGP30_CMD_GET_IAQ_BASELINE_WORDS);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
*baseline = ((uint32_t)words[1] << 16) | ((uint32_t)words[0]);
|
||
|
||
if (*baseline)
|
||
return STATUS_OK;
|
||
return STATUS_FAIL;
|
||
}
|
||
|
||
int16_t sgp30_set_iaq_baseline(uint32_t baseline)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[2] = {(uint16_t)((baseline & 0xffff0000) >> 16),
|
||
(uint16_t)(baseline & 0x0000ffff)};
|
||
|
||
if (!baseline)
|
||
return STATUS_FAIL;
|
||
|
||
ret = sensirion_i2c_write_cmd_with_args(SGP30_I2C_ADDRESS,
|
||
SGP30_CMD_SET_IAQ_BASELINE, words,
|
||
SENSIRION_NUM_WORDS(words));
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_SET_IAQ_BASELINE_DURATION_US);
|
||
|
||
return ret;
|
||
}
|
||
|
||
int16_t sgp30_get_tvoc_inceptive_baseline(uint16_t *tvoc_inceptive_baseline)
|
||
{
|
||
int16_t ret;
|
||
|
||
ret = sgp30_check_featureset(0x21);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
ret = sensirion_i2c_write_cmd(SGP30_I2C_ADDRESS,
|
||
SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE_DURATION_US);
|
||
|
||
return sensirion_i2c_read_words(
|
||
SGP30_I2C_ADDRESS, tvoc_inceptive_baseline,
|
||
SGP30_CMD_GET_TVOC_INCEPTIVE_BASELINE_WORDS);
|
||
}
|
||
|
||
int16_t sgp30_set_tvoc_baseline(uint16_t tvoc_baseline)
|
||
{
|
||
int16_t ret;
|
||
|
||
ret = sgp30_check_featureset(0x21);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
if (!tvoc_baseline)
|
||
return STATUS_FAIL;
|
||
|
||
ret = sensirion_i2c_write_cmd_with_args(
|
||
SGP30_I2C_ADDRESS, SGP30_CMD_SET_TVOC_BASELINE, &tvoc_baseline,
|
||
SENSIRION_NUM_WORDS(tvoc_baseline));
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_SET_TVOC_BASELINE_DURATION_US);
|
||
|
||
return ret;
|
||
}
|
||
|
||
int16_t sgp30_set_absolute_humidity(uint32_t absolute_humidity)
|
||
{
|
||
int16_t ret;
|
||
uint16_t ah_scaled;
|
||
|
||
if (absolute_humidity > 256000)
|
||
return STATUS_FAIL;
|
||
|
||
/* ah_scaled = (absolute_humidity / 1000) * 256 */
|
||
ah_scaled = (uint16_t)((absolute_humidity * 16777) >> 16);
|
||
|
||
ret = sensirion_i2c_write_cmd_with_args(
|
||
SGP30_I2C_ADDRESS, SGP30_CMD_SET_ABSOLUTE_HUMIDITY, &ah_scaled,
|
||
SENSIRION_NUM_WORDS(ah_scaled));
|
||
|
||
sensirion_sleep_usec(SGP30_CMD_SET_ABSOLUTE_HUMIDITY_DURATION_US);
|
||
|
||
return ret;
|
||
}
|
||
|
||
const char *sgp30_get_driver_version()
|
||
{
|
||
return SGP_DRV_VERSION_STR;
|
||
}
|
||
|
||
uint8_t sgp30_get_configured_address()
|
||
{
|
||
return SGP30_I2C_ADDRESS;
|
||
}
|
||
|
||
int16_t sgp30_get_feature_set_version(uint16_t *feature_set_version,
|
||
uint8_t *product_type)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[SGP30_CMD_GET_FEATURESET_WORDS];
|
||
|
||
ret = sensirion_i2c_delayed_read_cmd(SGP30_I2C_ADDRESS,
|
||
SGP30_CMD_GET_FEATURESET,
|
||
SGP30_CMD_GET_FEATURESET_DURATION_US,
|
||
words, SGP30_CMD_GET_FEATURESET_WORDS);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
*feature_set_version = words[0] & 0x00FF;
|
||
*product_type = (uint8_t)((words[0] & 0xF000) >> 12);
|
||
|
||
return STATUS_OK;
|
||
}
|
||
|
||
int16_t sgp30_get_serial_id(uint64_t *serial_id)
|
||
{
|
||
int16_t ret;
|
||
uint16_t words[SGP30_CMD_GET_SERIAL_ID_WORDS];
|
||
|
||
ret = sensirion_i2c_delayed_read_cmd(SGP30_I2C_ADDRESS,
|
||
SGP30_CMD_GET_SERIAL_ID,
|
||
SGP30_CMD_GET_SERIAL_ID_DURATION_US,
|
||
words, SGP30_CMD_GET_SERIAL_ID_WORDS);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
*serial_id = (((uint64_t)words[0]) << 32) | (((uint64_t)words[1]) << 16) |
|
||
(((uint64_t)words[2]) << 0);
|
||
|
||
return STATUS_OK;
|
||
}
|
||
|
||
int16_t sgp30_iaq_init()
|
||
{
|
||
int16_t ret =
|
||
sensirion_i2c_write_cmd(SGP30_I2C_ADDRESS, SGP30_CMD_IAQ_INIT);
|
||
sensirion_sleep_usec(SGP30_CMD_IAQ_INIT_DURATION_US);
|
||
return ret;
|
||
}
|
||
|
||
int16_t sgp30_probe()
|
||
{
|
||
int16_t ret = sgp30_check_featureset(0x20);
|
||
|
||
if (ret != STATUS_OK)
|
||
return ret;
|
||
|
||
return sgp30_iaq_init();
|
||
}
|
||
|
||
|
||
|
||
|
||
/*
|
||
* Copyright (c) 2018, Sensirion AG
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* * Redistributions of source code must retain the above copyright notice, this
|
||
* list of conditions and the following disclaimer.
|
||
*
|
||
* * Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
*
|
||
* * Neither the name of Sensirion AG nor the names of its
|
||
* contributors may be used to endorse or promote products derived from
|
||
* this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
#include "sgp30.h"
|
||
|
||
#include <inttypes.h> // PRIu64
|
||
#include <stdio.h> // printf
|
||
#include <unistd.h> // sleep
|
||
|
||
/* TO USE CONSOLE OUTPUT (printf) AND WAIT (sleep) YOU MAY NEED TO ADAPT THE
|
||
* INCLUDES ABOVE OR DEFINE THEM ACCORDING TO YOUR PLATFORM.
|
||
* #define printf(...)
|
||
* #define sleep(...)
|
||
*/
|
||
|
||
int uut_sgp30_main(void) {
|
||
uint16_t i = 0;
|
||
int16_t err;
|
||
uint16_t tvoc_ppb, co2_eq_ppm;
|
||
uint32_t iaq_baseline;
|
||
uint16_t ethanol_raw_signal, h2_raw_signal;
|
||
|
||
const char* driver_version = sgp30_get_driver_version();
|
||
if (driver_version) {
|
||
printf("SGP30 driver version %s\n", driver_version);
|
||
} else {
|
||
printf("fatal: Getting driver version failed\n");
|
||
return -1;
|
||
}
|
||
|
||
/* Initialize I2C bus */
|
||
sensirion_i2c_init();
|
||
|
||
/* Busy loop for initialization. The main loop does not work without
|
||
* a sensor. */
|
||
int16_t probe;
|
||
while (1) {
|
||
probe = sgp30_probe();
|
||
|
||
if (probe == STATUS_OK)
|
||
break;
|
||
|
||
if (probe == SGP30_ERR_UNSUPPORTED_FEATURE_SET)
|
||
printf(
|
||
"Your sensor needs at least feature set version 1.0 (0x20)\n");
|
||
|
||
printf("SGP sensor probing failed\n");
|
||
sensirion_sleep_usec(1000000);
|
||
}
|
||
|
||
printf("SGP sensor probing successful\n");
|
||
|
||
uint16_t feature_set_version;
|
||
uint8_t product_type;
|
||
err = sgp30_get_feature_set_version(&feature_set_version, &product_type);
|
||
if (err == STATUS_OK) {
|
||
printf("Feature set version: %u\n", feature_set_version);
|
||
printf("Product type: %u\n", product_type);
|
||
} else {
|
||
printf("sgp30_get_feature_set_version failed!\n");
|
||
}
|
||
uint64_t serial_id;
|
||
err = sgp30_get_serial_id(&serial_id);
|
||
if (err == STATUS_OK) {
|
||
printf("SerialID: %" PRIu64 "\n", serial_id);
|
||
} else {
|
||
printf("sgp30_get_serial_id failed!\n");
|
||
}
|
||
|
||
/* Read gas raw signals */
|
||
err = sgp30_measure_raw_blocking_read(ðanol_raw_signal, &h2_raw_signal);
|
||
if (err == STATUS_OK) {
|
||
/* Print ethanol raw signal and h2 raw signal */
|
||
printf("Ethanol raw signal: %u\n", ethanol_raw_signal);
|
||
printf("H2 raw signal: %u\n", h2_raw_signal);
|
||
} else {
|
||
printf("error reading raw signals\n");
|
||
}
|
||
|
||
/* Consider the two cases (A) and (B):
|
||
* (A) If no baseline is available or the most recent baseline is more than
|
||
* one week old, it must discarded. A new baseline is found with
|
||
* sgp30_iaq_init() */
|
||
err = sgp30_iaq_init();
|
||
if (err == STATUS_OK) {
|
||
printf("sgp30_iaq_init done\n");
|
||
} else {
|
||
printf("sgp30_iaq_init failed!\n");
|
||
}
|
||
/* (B) If a recent baseline is available, set it after sgp30_iaq_init() for
|
||
* faster start-up */
|
||
/* IMPLEMENT: retrieve iaq_baseline from presistent storage;
|
||
* err = sgp30_set_iaq_baseline(iaq_baseline);
|
||
*/
|
||
|
||
/* Run periodic IAQ measurements at defined intervals */
|
||
while (1) {
|
||
/*
|
||
* IMPLEMENT: get absolute humidity to enable humidity compensation
|
||
* uint32_t ah = get_absolute_humidity(); // absolute humidity in mg/m^3
|
||
* sgp30_set_absolute_humidity(ah);
|
||
*/
|
||
|
||
err = sgp30_measure_iaq_blocking_read(&tvoc_ppb, &co2_eq_ppm);
|
||
if (err == STATUS_OK) {
|
||
printf("tVOC Concentration: %dppb\n", tvoc_ppb);
|
||
printf("CO2eq Concentration: %dppm\n", co2_eq_ppm);
|
||
} else {
|
||
printf("error reading IAQ values\n");
|
||
}
|
||
|
||
/* Persist the current baseline every hour */
|
||
if (++i % 3600 == 3599) {
|
||
err = sgp30_get_iaq_baseline(&iaq_baseline);
|
||
if (err == STATUS_OK) {
|
||
/* IMPLEMENT: store baseline to presistent storage */
|
||
}
|
||
}
|
||
|
||
/* The IAQ measurement must be triggered exactly once per second (SGP30)
|
||
* to get accurate values.
|
||
*/
|
||
sleep(1); // SGP30
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/**********************************************************
|
||
*@file sgp30.h
|
||
*@brief
|
||
* 基于STM32 HAL 库的SGP30 甲醛传感器驱动
|
||
*
|
||
*@note
|
||
* 1. 驱动默认使用硬件i2c 1
|
||
* 2. 如果不需要打印报错信息，可以去掉printf相关
|
||
**********************************************************/
|
||
|
||
#include "sgp30.h"
|
||
|
||
sgp30_data_t sgp30_data;
|
||
I2C_HandleTypeDef SGP30_I2C_Handle_Name;
|
||
|
||
/**
|
||
* @brief 向SGP30发送一条指令(16bit)
|
||
* @param cmd SGP30指令
|
||
* @retval 成功返回HAL_OK
|
||
*/
|
||
|
||
static uint8_t sgp30_send_cmd(sgp30_cmd_t cmd)
|
||
{
|
||
uint8_t cmd_buffer[2];
|
||
cmd_buffer[0] = cmd >> 8;
|
||
cmd_buffer[1] = cmd;
|
||
return HAL_I2C_Master_Transmit(&SGP30_I2C_Handle_Name, SGP30_ADDR_WRITE, (uint8_t*) cmd_buffer, 2, 0xFFFF);
|
||
}
|
||
|
||
/**
|
||
* @brief 软复位SGP30
|
||
* @param none
|
||
* @retval 成功返回HAL_OK
|
||
*/
|
||
static int sgp30_soft_reset(void)
|
||
{
|
||
uint8_t cmd = 0x06;
|
||
return HAL_I2C_Master_Transmit(&SGP30_I2C_Handle_Name, 0x00, &cmd, 1, 0xFFFF);
|
||
}
|
||
|
||
/**
|
||
* @brief 初始化SGP30空气质量测量模式
|
||
* @param none
|
||
* @retval 成功返回0，失败返回-1
|
||
*/
|
||
int sgp30_init(void)
|
||
{
|
||
int status;
|
||
|
||
status = sgp30_soft_reset();
|
||
if (status != HAL_OK) {
|
||
return -1;
|
||
}
|
||
|
||
HAL_Delay(100);
|
||
|
||
status = sgp30_send_cmd(INIT_AIR_QUALITY);
|
||
|
||
HAL_Delay(100);
|
||
|
||
return status == 0 ? 0 : -1;
|
||
}
|
||
|
||
/**
|
||
* @brief 初始化SGP30空气质量测量模式
|
||
* @param none
|
||
* @retval 成功返回HAL_OK
|
||
*/
|
||
static int sgp30_start(void)
|
||
{
|
||
return sgp30_send_cmd(MEASURE_AIR_QUALITY);
|
||
}
|
||
|
||
#define CRC8_POLYNOMIAL 0x31
|
||
|
||
static uint8_t CheckCrc8(uint8_t* const message, uint8_t initial_value)
|
||
{
|
||
uint8_t remainder; //余数
|
||
uint8_t i = 0, j = 0; ////循环变量
|
||
|
||
/* 初始化 */
|
||
remainder = initial_value;
|
||
|
||
for(j = 0; j < 2;j++)
|
||
{
|
||
remainder ^= message[j];
|
||
|
||
/* 从最高位开始依次计算 */
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
if (remainder & 0x80)
|
||
{
|
||
remainder = (remainder << 1)^CRC8_POLYNOMIAL;
|
||
}
|
||
else
|
||
{
|
||
remainder = (remainder << 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 返回计算的CRC码 */
|
||
return remainder;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取一次空气质量数据
|
||
* @param none
|
||
* @retval 成功返回0，失败返回-1
|
||
*/
|
||
int sgp30_read(void)
|
||
{
|
||
int status;
|
||
uint8_t recv_buffer[6]={0};
|
||
|
||
/* 启动测量 */
|
||
status = sgp30_start();
|
||
if (status != 0) {
|
||
printf("sgp30 start fail\r\n");
|
||
return -1;
|
||
}
|
||
|
||
HAL_Delay(100);
|
||
|
||
/* 读取测量数据 */
|
||
status = HAL_I2C_Master_Receive(&SGP30_I2C_Handle_Name, SGP30_ADDR_READ, (uint8_t*)recv_buffer, 6, 0xFFFF);
|
||
if (status != HAL_OK) {
|
||
printf("I2C Master Receive fail\r\n");
|
||
return -1;
|
||
}
|
||
|
||
/* 校验接收的测量数据 */
|
||
if (CheckCrc8(&recv_buffer[0], 0xFF) != recv_buffer[2]) {
|
||
printf("co2 recv data crc check fail\r\n");
|
||
return -1;
|
||
}
|
||
if (CheckCrc8(&recv_buffer[3], 0xFF) != recv_buffer[5]) {
|
||
printf("tvoc recv data crc check fail\r\n");
|
||
return -1;
|
||
}
|
||
|
||
|
||
/* 转换测量数据 */
|
||
sgp30_data.co2 = recv_buffer[0] << 8 | recv_buffer[1];
|
||
sgp30_data.tvoc = recv_buffer[3] << 8 | recv_buffer[4];
|
||
|
||
return 0;
|
||
}
|
||
|