feat(firmware): support configurable SEN54 and SEN66 boards
Add the pinned Sensirion SEN66 driver, central sensor and board profiles, and a separate GPIO I2C bus for SEN66 with display. Preserve the original display layout and keep NOx and CO2 in InfluxDB. Include protocol tests, hardware workflow documentation and verified deployment results without credentials.
This commit is contained in:
@@ -1,11 +1,13 @@
|
||||
idf_component_register(
|
||||
SRCS
|
||||
"sen5x_i2c.c"
|
||||
"sen66_i2c.c"
|
||||
"sensirion_common.c"
|
||||
"sensirion_i2c.c"
|
||||
"sensirion_i2c_hal.c"
|
||||
"sensor_soft_i2c.c"
|
||||
"i2cdev.c"
|
||||
"sen5x_app.c"
|
||||
"air_sensor_app.c"
|
||||
INCLUDE_DIRS
|
||||
"."
|
||||
REQUIRES
|
||||
@@ -14,4 +16,6 @@ idf_component_register(
|
||||
log
|
||||
net_influx
|
||||
eez_gui
|
||||
storage
|
||||
hardware_config
|
||||
)
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
BSD 3-Clause License
|
||||
|
||||
Copyright (c) 2026, 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:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
2. 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.
|
||||
|
||||
3. Neither the name of the copyright holder 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.
|
||||
@@ -0,0 +1,19 @@
|
||||
# Sensirion driver provenance
|
||||
|
||||
Source: https://github.com/Sensirion/embedded-i2c-sen66
|
||||
|
||||
Pinned commit: `31cae0dd5253d256e8e647408ea1c544eff5d1c2` (retrieved 2026-11-09).
|
||||
|
||||
Unmodified upstream files: `sen66_i2c.c`, `sen66_i2c.h`, `sensirion_common.c`,
|
||||
`sensirion_common.h`, `sensirion_i2c.c`, `sensirion_i2c.h`, `sensirion_config.h`.
|
||||
License: `LICENSE.sensirion` (BSD-3-Clause). The common helpers also provide the
|
||||
API used by the existing SEN5x driver. `sensirion_i2c_hal.c` remains our ESP-IDF
|
||||
port using the shared, mutex-protected i2cdev hardware bus when sensor and
|
||||
board pins match. SEN66 with the display uses a separate local open-drain GPIO
|
||||
I2C engine (`sensor_soft_i2c.c/.h`) on GPIO7/8; touch retains hardware I2C on
|
||||
GPIO18/19. The GPIO engine has its own wire-level ACK/NACK/stretch/timeout tests.
|
||||
No upstream example HAL is
|
||||
compiled. The manufacturer driver files retain their original copyright text.
|
||||
|
||||
`sen5x_i2c.c/.h` are the existing SEN5x driver; `air_sensor_app.c` selects the
|
||||
SEN54 or SEN66 command API at compile time using `hardware_config.h`.
|
||||
+85
-71
@@ -1,6 +1,6 @@
|
||||
// File: src/sen5x_app.c
|
||||
// File: src/air_sensor_app.c
|
||||
|
||||
#include "sen5x_app.h"
|
||||
#include "air_sensor_app.h"
|
||||
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
@@ -9,7 +9,12 @@
|
||||
#include "esp_log.h"
|
||||
#include "sensirion_i2c_hal.h"
|
||||
#include "sensirion_i2c_esp32_config.h"
|
||||
#include "hardware_config.h"
|
||||
#if NANOPSX_SENSOR == NANOPSX_SENSOR_SEN66
|
||||
#include "sen66_i2c.h"
|
||||
#else
|
||||
#include "sen5x_i2c.h"
|
||||
#endif
|
||||
|
||||
#include "net_influx.h"
|
||||
#include "storage.h"
|
||||
@@ -20,11 +25,11 @@
|
||||
#include <math.h> // NAN, isfinite, lround
|
||||
#include "vars.h"
|
||||
|
||||
static const char* TAG = "sen5x_app";
|
||||
static const char* TAG = "air_sensor_app";
|
||||
|
||||
/* ====================== Konfiguration ====================== */
|
||||
#define SEN5X_PROD_STACK 4096
|
||||
#define SEN5X_PROD_PRIO 6 // Producer leicht höher priorisiert
|
||||
#define AIR_SENSOR_PROD_STACK 4096
|
||||
#define AIR_SENSOR_PROD_PRIO 6 // Producer leicht höher priorisiert
|
||||
|
||||
// Influx worker runtime (läuft in net_influx.c)
|
||||
#define INFLUX_QUEUE_LEN 16
|
||||
@@ -42,7 +47,7 @@ typedef struct {
|
||||
uint16_t pm1p0, pm2p5, pm4p0, pm10p0; // Rohwerte (x10)
|
||||
float temp_c, rh_pct; // skaliert
|
||||
int16_t voc_idx, nox_idx; // Rohwerte (x10)
|
||||
} sen5x_sample_t;
|
||||
} air_sensor_sample_t;
|
||||
|
||||
static bool g_inited = false;
|
||||
static bool g_run = false;
|
||||
@@ -68,52 +73,54 @@ static char* g_device_tag = NULL; // z.B. "device=xyz"
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* ====================== Lokale Float-Wrapper (optional) ====================== */
|
||||
static int16_t sen5x_read_measured_values_float(float* pm1p0, float* pm2p5,
|
||||
float* pm4p0, float* pm10p0,
|
||||
float* rh, float* t,
|
||||
float* voc, float* nox) {
|
||||
uint16_t pm1_i=0, pm2_i=0, pm4_i=0, pm10_i=0;
|
||||
int16_t rh_i=0, t_i=0, voc_i=0, nox_i=0;
|
||||
int16_t err = sen5x_read_measured_values(&pm1_i, &pm2_i, &pm4_i, &pm10_i,
|
||||
&rh_i, &t_i, &voc_i, &nox_i);
|
||||
if (err) return err;
|
||||
|
||||
if (pm1p0) *pm1p0 = (pm1_i == 0xFFFF) ? NAN : pm1_i / 10.0f;
|
||||
if (pm2p5) *pm2p5 = (pm2_i == 0xFFFF) ? NAN : pm2_i / 10.0f;
|
||||
if (pm4p0) *pm4p0 = (pm4_i == 0xFFFF) ? NAN : pm4_i / 10.0f;
|
||||
if (pm10p0) *pm10p0 = (pm10_i == 0xFFFF) ? NAN : pm10_i / 10.0f;
|
||||
|
||||
if (rh) *rh = (rh_i == 0x7FFF) ? NAN : rh_i / 100.0f;
|
||||
if (t) *t = (t_i == 0x7FFF) ? NAN : t_i / 200.0f;
|
||||
if (voc) *voc = (voc_i == 0x7FFF) ? NAN : voc_i / 10.0f;
|
||||
if (nox) *nox = (nox_i == 0x7FFF) ? NAN : nox_i / 10.0f;
|
||||
return 0;
|
||||
/* One selected command set; shared HAL and presentation/Influx pipeline. */
|
||||
static int16_t sensor_ready(bool *ready) {
|
||||
#if NANOPSX_SENSOR == NANOPSX_SENSOR_SEN66
|
||||
uint8_t padding;
|
||||
return sen66_get_data_ready(&padding, ready);
|
||||
#else
|
||||
return sen5x_read_data_ready(ready);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int16_t sen5x_read_measured_pm_values_float(float* pm1, float* pm2,
|
||||
float* pm4, float* pm10,
|
||||
float* n05, float* n10,
|
||||
float* n25, float* n40,
|
||||
float* n100, float* dtyp) {
|
||||
uint16_t pm1_i=0, pm2_i=0, pm4_i=0, pm10_i=0, n05_i=0, n10_i=0, n25_i=0, n40_i=0, n100_i=0, dtyp_i=0;
|
||||
int16_t err = sen5x_read_measured_pm_values(&pm1_i, &pm2_i, &pm4_i, &pm10_i,
|
||||
&n05_i, &n10_i, &n25_i, &n40_i, &n100_i, &dtyp_i);
|
||||
if (err) return err;
|
||||
static int16_t sensor_read(uint16_t *pm1, uint16_t *pm2, uint16_t *pm4,
|
||||
uint16_t *pm10, int16_t *rh, int16_t *temp,
|
||||
int16_t *voc, int16_t *nox, uint16_t *co2) {
|
||||
#if NANOPSX_SENSOR == NANOPSX_SENSOR_SEN66
|
||||
return sen66_read_measured_values_as_integers(pm1, pm2, pm4, pm10,
|
||||
rh, temp, voc, nox, co2);
|
||||
#else
|
||||
*co2 = UINT16_MAX; // SEN54 has no CO2 channel: never submit a fake zero.
|
||||
return sen5x_read_measured_values(pm1, pm2, pm4, pm10, rh, temp, voc, nox);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (pm1) *pm1 = (pm1_i == 0xFFFF) ? NAN : pm1_i / 10.0f;
|
||||
if (pm2) *pm2 = (pm2_i == 0xFFFF) ? NAN : pm2_i / 10.0f;
|
||||
if (pm4) *pm4 = (pm4_i == 0xFFFF) ? NAN : pm4_i / 10.0f;
|
||||
if (pm10) *pm10 = (pm10_i == 0xFFFF) ? NAN : pm10_i / 10.0f;
|
||||
static int16_t sensor_start(void) {
|
||||
#if NANOPSX_SENSOR == NANOPSX_SENSOR_SEN66
|
||||
sen66_init(NANOPSX_SENSOR_ADDRESS);
|
||||
// A sensor can keep measuring across an ESP-only reset.
|
||||
int16_t rc = sen66_stop_measurement();
|
||||
if (rc) return rc;
|
||||
int8_t product[32] = {0};
|
||||
rc = sen66_get_product_name(product, sizeof(product) - 1);
|
||||
if (rc) return rc;
|
||||
if (strncmp((const char *)product, "SEN66", 5) != 0) {
|
||||
ESP_LOGE(TAG, "Expected SEN66, product=%s", (char *)product);
|
||||
return -1;
|
||||
}
|
||||
ESP_LOGI(TAG, "Sensor identified: %s", (char *)product);
|
||||
return sen66_start_continuous_measurement();
|
||||
#else
|
||||
return sen5x_start_measurement();
|
||||
#endif
|
||||
}
|
||||
|
||||
if (n05) *n05 = (n05_i == 0xFFFF) ? NAN : n05_i / 10.0f;
|
||||
if (n10) *n10 = (n10_i == 0xFFFF) ? NAN : n10_i / 10.0f;
|
||||
if (n25) *n25 = (n25_i == 0xFFFF) ? NAN : n25_i / 10.0f;
|
||||
if (n40) *n40 = (n40_i == 0xFFFF) ? NAN : n40_i / 10.0f;
|
||||
if (n100) *n100 = (n100_i == 0xFFFF) ? NAN : n100_i / 10.0f;
|
||||
|
||||
if (dtyp) *dtyp = (dtyp_i == 0xFFFF) ? NAN : dtyp_i / 1000.0f; // µm
|
||||
return 0;
|
||||
static int16_t sensor_stop(void) {
|
||||
#if NANOPSX_SENSOR == NANOPSX_SENSOR_SEN66
|
||||
return sen66_stop_measurement();
|
||||
#else
|
||||
return sen5x_stop_measurement();
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ====================== App-Context: Device Tag ====================== */
|
||||
@@ -137,7 +144,7 @@ static esp_err_t make_device_tag_once(void) {
|
||||
}
|
||||
|
||||
/* ====================== Producer-Task ====================== */
|
||||
static void sen5x_task_producer(void* arg) {
|
||||
static void air_sensor_task_producer(void* arg) {
|
||||
(void)arg;
|
||||
|
||||
const TickType_t period = pdMS_TO_TICKS(1000); // exakt 1 Hz
|
||||
@@ -147,26 +154,26 @@ static void sen5x_task_producer(void* arg) {
|
||||
|
||||
for (; g_run; ) {
|
||||
bool ready = false;
|
||||
int16_t rc = sen5x_read_data_ready(&ready);
|
||||
int16_t rc = sensor_ready(&ready);
|
||||
if (rc != 0) {
|
||||
ESP_LOGW(TAG, "sen5x_read_data_ready error: %d", (int)rc);
|
||||
ESP_LOGW(TAG, "sensor_ready error: %d", (int)rc);
|
||||
} else if (ready) {
|
||||
uint16_t pm1p0=0, pm2p5=0, pm4p0=0, pm10p0=0;
|
||||
uint16_t pm1p0=0, pm2p5=0, pm4p0=0, pm10p0=0, co2_raw=UINT16_MAX;
|
||||
int16_t rh_raw=0, t_raw=0, voc_idx=0, nox_idx=0;
|
||||
|
||||
rc = sen5x_read_measured_values(&pm1p0, &pm2p5, &pm4p0, &pm10p0,
|
||||
&rh_raw, &t_raw, &voc_idx, &nox_idx);
|
||||
rc = sensor_read(&pm1p0, &pm2p5, &pm4p0, &pm10p0,
|
||||
&rh_raw, &t_raw, &voc_idx, &nox_idx, &co2_raw);
|
||||
if (rc != 0) {
|
||||
ESP_LOGW(TAG, "sen5x_read_measured_values error: %d", (int)rc);
|
||||
ESP_LOGW(TAG, "sensor_read error: %d", (int)rc);
|
||||
} else {
|
||||
// Roh → Struct (wie bisher)
|
||||
sen5x_sample_t s = {
|
||||
air_sensor_sample_t s = {
|
||||
.pm1p0 = pm1p0,
|
||||
.pm2p5 = pm2p5,
|
||||
.pm4p0 = pm4p0,
|
||||
.pm10p0 = pm10p0,
|
||||
.temp_c = ((float)t_raw) / 200.0f,
|
||||
.rh_pct = ((float)rh_raw) / 100.0f,
|
||||
.temp_c = (t_raw == INT16_MAX) ? NAN : ((float)t_raw) / 200.0f,
|
||||
.rh_pct = (rh_raw == INT16_MAX) ? NAN : ((float)rh_raw) / 100.0f,
|
||||
.voc_idx = voc_idx,
|
||||
.nox_idx = nox_idx
|
||||
};
|
||||
@@ -212,6 +219,12 @@ static void sen5x_task_producer(void* arg) {
|
||||
const double nox = (s.nox_idx == 0x7FFF) ? NAN : ((double)s.nox_idx / 10.0);
|
||||
const double temp = (double)s.temp_c;
|
||||
const double rh = (double)s.rh_pct;
|
||||
const double co2 = (co2_raw == UINT16_MAX) ? NAN : (double)co2_raw;
|
||||
static unsigned samples;
|
||||
if (++samples % 10 == 0) {
|
||||
ESP_LOGI(TAG, "%s sample: PM2.5=%.1f temp=%.2f rh=%.2f CO2=%.0f",
|
||||
NANOPSX_SENSOR_NAME, pm2_5, temp, rh, co2);
|
||||
}
|
||||
|
||||
net_influx_field_t f[] = {
|
||||
{ .key="pm1", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=pm1 },
|
||||
@@ -222,6 +235,7 @@ static void sen5x_task_producer(void* arg) {
|
||||
{ .key="rh", .type=NET_INFLUX_F_FLOAT, .precision=3, .v.f=rh },
|
||||
{ .key="voc", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=voc },
|
||||
{ .key="nox", .type=NET_INFLUX_F_FLOAT, .precision=1, .v.f=nox },
|
||||
{ .key="co2", .type=NET_INFLUX_F_FLOAT, .precision=0, .v.f=co2 },
|
||||
};
|
||||
|
||||
net_influx_point_t p = {
|
||||
@@ -245,14 +259,14 @@ static void sen5x_task_producer(void* arg) {
|
||||
}
|
||||
|
||||
/* ====================== Öffentliche API ====================== */
|
||||
esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
|
||||
esp_err_t air_sensor_app_init(const air_sensor_i2c_cfg_t* cfg) {
|
||||
if (g_inited) {
|
||||
ESP_LOGW(TAG, "already initialized");
|
||||
return ESP_OK;
|
||||
}
|
||||
if (!cfg) return ESP_ERR_INVALID_ARG;
|
||||
|
||||
ESP_LOGI(TAG, "Initializing SEN5x app...");
|
||||
ESP_LOGI(TAG, "Initializing selected air sensor...");
|
||||
|
||||
// 1) I2C-Subsystem
|
||||
|
||||
@@ -274,7 +288,7 @@ esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
|
||||
CHECK_ESP_OR_RET(sensirion_i2c_esp32_ok());
|
||||
|
||||
// 4) Messung starten
|
||||
CHECK_SEN_OR_RET(sen5x_start_measurement());
|
||||
CHECK_SEN_OR_RET(sensor_start());
|
||||
ESP_LOGI(TAG, "Measurement started.");
|
||||
|
||||
// 5) Device Tag (App-Kontext)
|
||||
@@ -299,7 +313,7 @@ esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg) {
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
void sen5x_app_deinit(void) {
|
||||
void air_sensor_app_deinit(void) {
|
||||
if (!g_inited) return;
|
||||
|
||||
ESP_LOGI(TAG, "Deinitializing SEN5x app...");
|
||||
@@ -311,8 +325,8 @@ void sen5x_app_deinit(void) {
|
||||
}
|
||||
|
||||
if (g_task_prod) {
|
||||
ESP_LOGW(TAG, "Producer did not stop in time; skip sen5x_stop_measurement/HAL free");
|
||||
// Hier NICHT sen5x_stop_measurement() / HAL free, weil Task evtl. noch I2C nutzt
|
||||
ESP_LOGW(TAG, "Producer did not stop in time; skip sensor_stop/HAL free");
|
||||
// Hier NICHT sensor_stop() / HAL free, weil Task evtl. noch I2C nutzt
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -323,33 +337,33 @@ void sen5x_app_deinit(void) {
|
||||
g_device_tag = NULL;
|
||||
}
|
||||
|
||||
sen5x_stop_measurement();
|
||||
sensor_stop();
|
||||
sensirion_i2c_hal_free();
|
||||
|
||||
// i2cdev_done(); // NICHT hier, da Bus global genutzt wird
|
||||
|
||||
g_inited = false;
|
||||
ESP_LOGI(TAG, "SEN5x app deinitialized.");
|
||||
ESP_LOGI(TAG, "Air sensor app deinitialized.");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Kompatibilität zur bisherigen main.c:
|
||||
* Diese Task fungiert nun als "Launcher": startet Producer und beendet sich dann.
|
||||
* In main.c bleibt der Aufruf von xTaskCreate(sen5x_app_task, ...) unverändert.
|
||||
* In main.c bleibt der Aufruf von xTaskCreate(air_sensor_app_task, ...) unverändert.
|
||||
*/
|
||||
void sen5x_app_task(void* arg) {
|
||||
void air_sensor_app_task(void* arg) {
|
||||
(void)arg;
|
||||
|
||||
if (!g_inited) {
|
||||
ESP_LOGE(TAG, "sen5x_app_task called before sen5x_app_init()");
|
||||
ESP_LOGE(TAG, "air_sensor_app_task called before air_sensor_app_init()");
|
||||
vTaskDelete(NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
// Producer starten
|
||||
if (xTaskCreate(sen5x_task_producer, "sen5x_prod",
|
||||
SEN5X_PROD_STACK, NULL, SEN5X_PROD_PRIO, &g_task_prod) != pdPASS) {
|
||||
if (xTaskCreate(air_sensor_task_producer, "air_sensor_prod",
|
||||
AIR_SENSOR_PROD_STACK, NULL, AIR_SENSOR_PROD_PRIO, &g_task_prod) != pdPASS) {
|
||||
ESP_LOGE(TAG, "Failed to create producer task");
|
||||
vTaskDelete(NULL);
|
||||
return;
|
||||
@@ -5,20 +5,20 @@
|
||||
|
||||
// Schlanke I2C/HAL-Konfiguration (wie zuvor genutzt)
|
||||
typedef struct {
|
||||
uint8_t addr; // 7-bit I2C-Adresse (0x69)
|
||||
uint8_t addr; // selected sensor, 7-bit I2C address
|
||||
int port; // I2C Port (0)
|
||||
int sda; // GPIO SDA
|
||||
int scl; // GPIO SCL
|
||||
bool sda_pullup; // interne Pullups
|
||||
bool scl_pullup; // interne Pullups
|
||||
uint32_t freq; // I2C Takt (Hz, z.B. 400000)
|
||||
} sen5x_i2c_cfg_t;
|
||||
} air_sensor_i2c_cfg_t;
|
||||
|
||||
// Initialisiert I2C/Treiber/HAL und startet die Messung
|
||||
esp_err_t sen5x_app_init(const sen5x_i2c_cfg_t* cfg);
|
||||
esp_err_t air_sensor_app_init(const air_sensor_i2c_cfg_t* cfg);
|
||||
|
||||
// Endlosschleife (Pollt "data ready" und loggt Messwerte); als FreeRTOS-Task nutzbar
|
||||
void sen5x_app_task(void* arg);
|
||||
void air_sensor_app_task(void* arg);
|
||||
|
||||
// Stoppt Messung & gibt Ressourcen frei (optional aufzurufen z.B. bei Shutdown)
|
||||
void sen5x_app_deinit(void);
|
||||
void air_sensor_app_deinit(void);
|
||||
@@ -0,0 +1,798 @@
|
||||
/*
|
||||
* THIS FILE IS AUTOMATICALLY GENERATED
|
||||
*
|
||||
* Generator: sensirion-driver-generator 1.7.0
|
||||
* Product: sen66
|
||||
* Model-Version: 1.7.3
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2026, 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 "sen66_i2c.h"
|
||||
#include "sensirion_common.h"
|
||||
#include "sensirion_i2c.h"
|
||||
#include "sensirion_i2c_hal.h"
|
||||
|
||||
#define sensirion_hal_sleep_us sensirion_i2c_hal_sleep_usec
|
||||
|
||||
static uint8_t communication_buffer[48] = {0};
|
||||
|
||||
static uint8_t _i2c_address;
|
||||
|
||||
void sen66_init(uint8_t i2c_address) {
|
||||
_i2c_address = i2c_address;
|
||||
}
|
||||
|
||||
int16_t sen66_get_voc_algorithm_tuning_parameters(
|
||||
int16_t* index_offset, int16_t* learning_time_offset_hours,
|
||||
int16_t* learning_time_gain_hours, int16_t* gating_max_duration_minutes,
|
||||
int16_t* std_initial, int16_t* gain_factor) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_GET_VOC_ALGORITHM_TUNING_PARAMETERS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 12);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*index_offset = sensirion_common_bytes_to_int16_t(&buffer_ptr[0]);
|
||||
*learning_time_offset_hours =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[2]);
|
||||
*learning_time_gain_hours =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[4]);
|
||||
*gating_max_duration_minutes =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[6]);
|
||||
*std_initial = sensirion_common_bytes_to_int16_t(&buffer_ptr[8]);
|
||||
*gain_factor = sensirion_common_bytes_to_int16_t(&buffer_ptr[10]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_voc_algorithm_tuning_parameters(
|
||||
int16_t index_offset, int16_t learning_time_offset_hours,
|
||||
int16_t learning_time_gain_hours, int16_t gating_max_duration_minutes,
|
||||
int16_t std_initial, int16_t gain_factor) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_SET_VOC_ALGORITHM_TUNING_PARAMETERS_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
index_offset);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, learning_time_offset_hours);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, learning_time_gain_hours);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, gating_max_duration_minutes);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
std_initial);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
gain_factor);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_voc_algorithm_state(uint8_t* state, uint16_t state_size) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_VOC_ALGORITHM_STATE_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 8);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_common_copy_bytes(&buffer_ptr[0], (uint8_t*)state, state_size);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_voc_algorithm_state(const uint8_t* state,
|
||||
uint16_t state_size) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_SET_VOC_ALGORITHM_STATE_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_bytes_to_buffer(buffer_ptr, local_offset,
|
||||
state, state_size);
|
||||
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_nox_algorithm_tuning_parameters(
|
||||
int16_t* index_offset, int16_t* learning_time_offset_hours,
|
||||
int16_t* learning_time_gain_hours, int16_t* gating_max_duration_minutes,
|
||||
int16_t* std_initial, int16_t* gain_factor) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_GET_NOX_ALGORITHM_TUNING_PARAMETERS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 12);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*index_offset = sensirion_common_bytes_to_int16_t(&buffer_ptr[0]);
|
||||
*learning_time_offset_hours =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[2]);
|
||||
*learning_time_gain_hours =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[4]);
|
||||
*gating_max_duration_minutes =
|
||||
sensirion_common_bytes_to_int16_t(&buffer_ptr[6]);
|
||||
*std_initial = sensirion_common_bytes_to_int16_t(&buffer_ptr[8]);
|
||||
*gain_factor = sensirion_common_bytes_to_int16_t(&buffer_ptr[10]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_nox_algorithm_tuning_parameters(
|
||||
int16_t index_offset, int16_t learning_time_offset_hours,
|
||||
int16_t learning_time_gain_hours, int16_t gating_max_duration_minutes,
|
||||
int16_t std_initial, int16_t gain_factor) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_SET_NOX_ALGORITHM_TUNING_PARAMETERS_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
index_offset);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, learning_time_offset_hours);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, learning_time_gain_hours);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(
|
||||
buffer_ptr, local_offset, gating_max_duration_minutes);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
std_initial);
|
||||
local_offset = sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset,
|
||||
gain_factor);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t
|
||||
sen66_perform_forced_co2_recalibration(uint16_t target_co2_concentration,
|
||||
uint16_t* correction) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_PERFORM_FORCED_CO2_RECALIBRATION_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_uint16_t_to_buffer(
|
||||
buffer_ptr, local_offset, target_co2_concentration);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(500 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*correction = sensirion_common_bytes_to_uint16_t(&buffer_ptr[0]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_perform_co2_sensor_factory_reset(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_PERFORM_CO2_SENSOR_FACTORY_RESET_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(1400 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_co2_sensor_automatic_self_calibration(uint8_t* padding,
|
||||
bool* status) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_GET_CO2_SENSOR_AUTOMATIC_SELF_CALIBRATION_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*padding = (uint8_t)buffer_ptr[0];
|
||||
*status = (bool)buffer_ptr[1];
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_co2_sensor_automatic_self_calibration(uint16_t status) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_SET_CO2_SENSOR_AUTOMATIC_SELF_CALIBRATION_CMD_ID);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, status);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_ambient_pressure(uint16_t* ambient_pressure) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_AMBIENT_PRESSURE_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*ambient_pressure = sensirion_common_bytes_to_uint16_t(&buffer_ptr[0]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_ambient_pressure(uint16_t ambient_pressure) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_SET_AMBIENT_PRESSURE_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_uint16_t_to_buffer(
|
||||
buffer_ptr, local_offset, ambient_pressure);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_sensor_altitude(uint16_t* altitude) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_SENSOR_ALTITUDE_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*altitude = sensirion_common_bytes_to_uint16_t(&buffer_ptr[0]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_sensor_altitude(uint16_t altitude) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_SET_SENSOR_ALTITUDE_CMD_ID);
|
||||
local_offset = sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr,
|
||||
local_offset, altitude);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_start_continuous_measurement(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_START_CONTINUOUS_MEASUREMENT_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(50 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_stop_measurement(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_STOP_MEASUREMENT_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(1400 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_data_ready(uint8_t* padding, bool* data_ready) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_DATA_READY_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*padding = (uint8_t)buffer_ptr[0];
|
||||
*data_ready = (bool)buffer_ptr[1];
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_read_number_concentration_values_as_integers(
|
||||
uint16_t* number_concentration_pm0p5, uint16_t* number_concentration_pm1p0,
|
||||
uint16_t* number_concentration_pm2p5, uint16_t* number_concentration_pm4p0,
|
||||
uint16_t* number_concentration_pm10p0) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_READ_NUMBER_CONCENTRATION_VALUES_AS_INTEGERS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 10);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*number_concentration_pm0p5 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[0]);
|
||||
*number_concentration_pm1p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[2]);
|
||||
*number_concentration_pm2p5 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[4]);
|
||||
*number_concentration_pm4p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[6]);
|
||||
*number_concentration_pm10p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[8]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_temperature_offset_parameters(int16_t offset, int16_t slope,
|
||||
uint16_t time_constant,
|
||||
uint16_t slot) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_SET_TEMPERATURE_OFFSET_PARAMETERS_CMD_ID);
|
||||
local_offset =
|
||||
sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset, offset);
|
||||
local_offset =
|
||||
sensirion_i2c_add_int16_t_to_buffer(buffer_ptr, local_offset, slope);
|
||||
local_offset = sensirion_i2c_add_uint16_t_to_buffer(
|
||||
buffer_ptr, local_offset, time_constant);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, slot);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_set_temperature_acceleration_parameters(uint16_t k, uint16_t p,
|
||||
uint16_t t1,
|
||||
uint16_t t2) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_SET_TEMPERATURE_ACCELERATION_PARAMETERS_CMD_ID);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, k);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, p);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, t1);
|
||||
local_offset =
|
||||
sensirion_i2c_add_uint16_t_to_buffer(buffer_ptr, local_offset, t2);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_product_type(int8_t* product_type,
|
||||
uint16_t product_type_size) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_PRODUCT_TYPE_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 32);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_common_copy_bytes(&buffer_ptr[0], (uint8_t*)product_type,
|
||||
product_type_size);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_product_name(int8_t* product_name,
|
||||
uint16_t product_name_size) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_PRODUCT_NAME_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 32);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_common_copy_bytes(&buffer_ptr[0], (uint8_t*)product_name,
|
||||
product_name_size);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_serial_number(int8_t* serial_number,
|
||||
uint16_t serial_number_size) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_SERIAL_NUMBER_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 32);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_common_copy_bytes(&buffer_ptr[0], (uint8_t*)serial_number,
|
||||
serial_number_size);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_read_device_status(sen66_device_status* device_status) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_READ_DEVICE_STATUS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 4);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
(*device_status).value = sensirion_common_bytes_to_uint32_t(&buffer_ptr[0]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_read_and_clear_device_status(sen66_device_status* device_status) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_READ_AND_CLEAR_DEVICE_STATUS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 4);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
(*device_status).value = sensirion_common_bytes_to_uint32_t(&buffer_ptr[0]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_version(uint8_t* firmware_major, uint8_t* firmware_minor) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_VERSION_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 2);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*firmware_major = (uint8_t)buffer_ptr[0];
|
||||
*firmware_minor = (uint8_t)buffer_ptr[1];
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_device_reset(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_DEVICE_RESET_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(1200 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_start_fan_cleaning(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_START_FAN_CLEANING_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_activate_sht_heater(void) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_ACTIVATE_SHT_HEATER_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_get_sht_heater_measurements(int16_t* sht_relative_humidity,
|
||||
int16_t* sht_temperature) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_GET_SHT_HEATER_MEASUREMENTS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 4);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*sht_relative_humidity = sensirion_common_bytes_to_int16_t(&buffer_ptr[0]);
|
||||
*sht_temperature = sensirion_common_bytes_to_int16_t(&buffer_ptr[2]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_read_measured_values_as_integers(
|
||||
uint16_t* mass_concentration_pm1p0, uint16_t* mass_concentration_pm2p5,
|
||||
uint16_t* mass_concentration_pm4p0, uint16_t* mass_concentration_pm10p0,
|
||||
int16_t* ambient_humidity, int16_t* ambient_temperature, int16_t* voc_index,
|
||||
int16_t* nox_index, uint16_t* co2) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset,
|
||||
SEN66_READ_MEASURED_VALUES_AS_INTEGERS_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 18);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*mass_concentration_pm1p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[0]);
|
||||
*mass_concentration_pm2p5 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[2]);
|
||||
*mass_concentration_pm4p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[4]);
|
||||
*mass_concentration_pm10p0 =
|
||||
sensirion_common_bytes_to_uint16_t(&buffer_ptr[6]);
|
||||
*ambient_humidity = sensirion_common_bytes_to_int16_t(&buffer_ptr[8]);
|
||||
*ambient_temperature = sensirion_common_bytes_to_int16_t(&buffer_ptr[10]);
|
||||
*voc_index = sensirion_common_bytes_to_int16_t(&buffer_ptr[12]);
|
||||
*nox_index = sensirion_common_bytes_to_int16_t(&buffer_ptr[14]);
|
||||
*co2 = sensirion_common_bytes_to_uint16_t(&buffer_ptr[16]);
|
||||
return local_error;
|
||||
}
|
||||
|
||||
int16_t sen66_read_measured_raw_values(int16_t* raw_humidity,
|
||||
int16_t* raw_temperature,
|
||||
uint16_t* raw_voc, uint16_t* raw_nox,
|
||||
uint16_t* raw_co2) {
|
||||
int16_t local_error = NO_ERROR;
|
||||
uint8_t* buffer_ptr = communication_buffer;
|
||||
uint16_t local_offset = 0;
|
||||
|
||||
local_offset = sensirion_i2c_add_command16_to_buffer(
|
||||
buffer_ptr, local_offset, SEN66_READ_MEASURED_RAW_VALUES_CMD_ID);
|
||||
local_error =
|
||||
sensirion_i2c_write_data(_i2c_address, buffer_ptr, local_offset);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
sensirion_i2c_hal_sleep_usec(20 * 1000);
|
||||
local_error = sensirion_i2c_read_data_inplace(_i2c_address, buffer_ptr, 10);
|
||||
if (local_error != NO_ERROR) {
|
||||
return local_error;
|
||||
}
|
||||
*raw_humidity = sensirion_common_bytes_to_int16_t(&buffer_ptr[0]);
|
||||
*raw_temperature = sensirion_common_bytes_to_int16_t(&buffer_ptr[2]);
|
||||
*raw_voc = sensirion_common_bytes_to_uint16_t(&buffer_ptr[4]);
|
||||
*raw_nox = sensirion_common_bytes_to_uint16_t(&buffer_ptr[6]);
|
||||
*raw_co2 = sensirion_common_bytes_to_uint16_t(&buffer_ptr[8]);
|
||||
return local_error;
|
||||
}
|
||||
@@ -0,0 +1,899 @@
|
||||
/*
|
||||
* THIS FILE IS AUTOMATICALLY GENERATED
|
||||
*
|
||||
* Generator: sensirion-driver-generator 1.7.0
|
||||
* Product: sen66
|
||||
* Model-Version: 1.7.3
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2026, 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.
|
||||
*/
|
||||
|
||||
#ifndef SEN66_I2C_H
|
||||
#define SEN66_I2C_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "sensirion_config.h"
|
||||
#define SEN66_I2C_ADDR_6B 0x6b
|
||||
|
||||
typedef enum {
|
||||
SEN66_GET_VOC_ALGORITHM_TUNING_PARAMETERS_CMD_ID = 0x60d0,
|
||||
SEN66_SET_VOC_ALGORITHM_TUNING_PARAMETERS_CMD_ID = 0x60d0,
|
||||
SEN66_GET_VOC_ALGORITHM_STATE_CMD_ID = 0x6181,
|
||||
SEN66_SET_VOC_ALGORITHM_STATE_CMD_ID = 0x6181,
|
||||
SEN66_GET_NOX_ALGORITHM_TUNING_PARAMETERS_CMD_ID = 0x60e1,
|
||||
SEN66_SET_NOX_ALGORITHM_TUNING_PARAMETERS_CMD_ID = 0x60e1,
|
||||
SEN66_PERFORM_FORCED_CO2_RECALIBRATION_CMD_ID = 0x6707,
|
||||
SEN66_PERFORM_CO2_SENSOR_FACTORY_RESET_CMD_ID = 0x6754,
|
||||
SEN66_GET_CO2_SENSOR_AUTOMATIC_SELF_CALIBRATION_CMD_ID = 0x6711,
|
||||
SEN66_SET_CO2_SENSOR_AUTOMATIC_SELF_CALIBRATION_CMD_ID = 0x6711,
|
||||
SEN66_GET_AMBIENT_PRESSURE_CMD_ID = 0x6720,
|
||||
SEN66_SET_AMBIENT_PRESSURE_CMD_ID = 0x6720,
|
||||
SEN66_GET_SENSOR_ALTITUDE_CMD_ID = 0x6736,
|
||||
SEN66_SET_SENSOR_ALTITUDE_CMD_ID = 0x6736,
|
||||
SEN66_START_CONTINUOUS_MEASUREMENT_CMD_ID = 0x21,
|
||||
SEN66_STOP_MEASUREMENT_CMD_ID = 0x104,
|
||||
SEN66_GET_DATA_READY_CMD_ID = 0x202,
|
||||
SEN66_READ_NUMBER_CONCENTRATION_VALUES_AS_INTEGERS_CMD_ID = 0x316,
|
||||
SEN66_SET_TEMPERATURE_OFFSET_PARAMETERS_CMD_ID = 0x60b2,
|
||||
SEN66_SET_TEMPERATURE_ACCELERATION_PARAMETERS_CMD_ID = 0x6100,
|
||||
SEN66_GET_PRODUCT_TYPE_CMD_ID = 0xd002,
|
||||
SEN66_GET_PRODUCT_NAME_CMD_ID = 0xd014,
|
||||
SEN66_GET_SERIAL_NUMBER_CMD_ID = 0xd033,
|
||||
SEN66_READ_DEVICE_STATUS_CMD_ID = 0xd206,
|
||||
SEN66_READ_AND_CLEAR_DEVICE_STATUS_CMD_ID = 0xd210,
|
||||
SEN66_GET_VERSION_CMD_ID = 0xd100,
|
||||
SEN66_DEVICE_RESET_CMD_ID = 0xd304,
|
||||
SEN66_START_FAN_CLEANING_CMD_ID = 0x5607,
|
||||
SEN66_ACTIVATE_SHT_HEATER_CMD_ID = 0x6765,
|
||||
SEN66_GET_SHT_HEATER_MEASUREMENTS_CMD_ID = 0x6790,
|
||||
SEN66_READ_MEASURED_VALUES_AS_INTEGERS_CMD_ID = 0x300,
|
||||
SEN66_READ_MEASURED_RAW_VALUES_CMD_ID = 0x405,
|
||||
} SEN66_CMD_ID;
|
||||
|
||||
typedef union {
|
||||
struct {
|
||||
uint32_t reserved1 : 4;
|
||||
uint32_t fan_error : 1;
|
||||
uint32_t reserved2 : 1;
|
||||
uint32_t rht_error : 1;
|
||||
uint32_t gas_error : 1;
|
||||
uint32_t reserved3 : 1;
|
||||
uint32_t co2_2_error : 1;
|
||||
uint32_t hcho_error : 1;
|
||||
uint32_t pm_error : 1;
|
||||
uint32_t co2_1_error : 1;
|
||||
uint32_t reserved4 : 8;
|
||||
uint32_t fan_speed_warning : 1;
|
||||
uint32_t reserved5 : 10;
|
||||
};
|
||||
uint32_t value;
|
||||
} sen66_device_status;
|
||||
|
||||
/**
|
||||
* @brief Initialize i2c address of driver
|
||||
*
|
||||
* @param[in] i2c_address Used i2c address
|
||||
*
|
||||
*/
|
||||
void sen66_init(uint8_t i2c_address);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_voc_algorithm_tuning_parameters
|
||||
*
|
||||
* Gets the parameters to customize the VOC algorithm.
|
||||
*
|
||||
* @param[out] index_offset VOC index representing typical (average) conditions.
|
||||
* @param[out] learning_time_offset_hours Time constant to estimate the VOC
|
||||
* algorithm offset from the history in hours. Past events will be forgotten
|
||||
* after about twice the learning time.
|
||||
* @param[out] learning_time_gain_hours Time constant to estimate the VOC
|
||||
* algorithm gain from the history in hours. Past events will be forgotten after
|
||||
* about twice the learning time.
|
||||
* @param[out] gating_max_duration_minutes Maximum duration of gating in minutes
|
||||
* (freeze of estimator during high VOC index signal). Zero disables the gating.
|
||||
* @param[out] std_initial Initial estimate for standard deviation. Lower value
|
||||
* boosts events during initial learning period, but may result in larger
|
||||
* device-to-device variations.
|
||||
* @param[out] gain_factor Gain factor to amplify or to attenuate the VOC index
|
||||
* output.
|
||||
*
|
||||
* @note This command is only available in idle mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_voc_algorithm_tuning_parameters(
|
||||
int16_t* index_offset, int16_t* learning_time_offset_hours,
|
||||
int16_t* learning_time_gain_hours, int16_t* gating_max_duration_minutes,
|
||||
int16_t* std_initial, int16_t* gain_factor);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_voc_algorithm_tuning_parameters
|
||||
*
|
||||
* Sets the parameters to customize the VOC algorithm. This configuration is
|
||||
* volatile, i.e. the parameters will be reverted to their default values after
|
||||
* a device reset.
|
||||
*
|
||||
* @param[in] index_offset VOC index representing typical (average) conditions.
|
||||
* Allowed values are in range 1..250. The default value is 100.
|
||||
* @param[in] learning_time_offset_hours Time constant to estimate the VOC
|
||||
* algorithm offset from the history in hours. Past events will be forgotten
|
||||
* after about twice the learning time. Allowed values are in range 1..1000. The
|
||||
* default value is 12 hours.
|
||||
* @param[in] learning_time_gain_hours Time constant to estimate the VOC
|
||||
* algorithm gain from the history in hours. Past events will be forgotten after
|
||||
* about twice the learning time. Allowed values are in range 1..1000. The
|
||||
* default value is 12 hours.
|
||||
* @param[in] gating_max_duration_minutes Maximum duration of gating in minutes
|
||||
* (freeze of estimator during high VOC index signal). Set to zero to disable
|
||||
* the gating. Allowed values are in range 0..3000. The default value is 180
|
||||
* minutes
|
||||
* @param[in] std_initial Initial estimate for standard deviation. Lower value
|
||||
* boosts events during initial learning period, but may result in larger
|
||||
* device-to-device variations. Allowed values are in range 10..5000. The
|
||||
* default value is 50.
|
||||
* @param[in] gain_factor Gain factor to amplify or to attenuate the VOC index
|
||||
* output. Allowed values are in range 1..1000. The default value is 230.
|
||||
*
|
||||
* @note This command is available only in idle mode. In measure mode, this
|
||||
* command has no effect. In addition, it has no effect if at least one
|
||||
* parameter is outside the specified range.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*
|
||||
* Example:
|
||||
* --------
|
||||
*
|
||||
* @code{.c}
|
||||
*
|
||||
* int16_t local_error = 0;
|
||||
*
|
||||
* local_error = sen66_set_voc_algorithm_tuning_parameters(100, 12, 12, 180,
|
||||
* 50, 230); if (local_error != NO_ERROR) { return local_error;
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*
|
||||
*/
|
||||
int16_t sen66_set_voc_algorithm_tuning_parameters(
|
||||
int16_t index_offset, int16_t learning_time_offset_hours,
|
||||
int16_t learning_time_gain_hours, int16_t gating_max_duration_minutes,
|
||||
int16_t std_initial, int16_t gain_factor);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_voc_algorithm_state
|
||||
*
|
||||
* Gets the current VOC algorithm state. Allows to backup and restore the VOC
|
||||
* algorithm state to resume operation after a power cycle or device reset,
|
||||
* skipping initial learning phase. By default, the VOC Engine is reset and the
|
||||
* algorithm state is retained if a measurement is stopped and started again.
|
||||
* If the VOC algorithm state shall be reset, a device reset or a power cycle
|
||||
* can be executed.
|
||||
*
|
||||
* @param[out] state Current VOC algorithm state.
|
||||
*
|
||||
* @note This command can be used either in measure mode or in idle mode (which
|
||||
* will then return the state at the time when the measurement was stopped). In
|
||||
* measure mode, the state can be read each measure interval to always have the
|
||||
* latest state available, even in case of a sudden power loss.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_voc_algorithm_state(uint8_t* state, uint16_t state_size);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_voc_algorithm_state
|
||||
*
|
||||
* Sets the VOC algorithm state previously received with "Get VOC Algorithm
|
||||
* State" command. Allows restoration of the VOC algorithm state to resume
|
||||
* operation after a power cycle or device reset, skipping initial learning
|
||||
* phase. By default, the VOC Engine is reset, and the algorithm state is
|
||||
* retained if a measurement is stopped and started again. If the VOC algorithm
|
||||
* state shall be reset, a device reset, or a power cycle can be executed.
|
||||
*
|
||||
* @param[in] state VOC algorithm state to restore.
|
||||
*
|
||||
* @note This command is only available in idle mode and the state will be
|
||||
* applied only once when starting the next measurement. In measure mode, this
|
||||
* command has no effect.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_set_voc_algorithm_state(const uint8_t* state,
|
||||
uint16_t state_size);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_nox_algorithm_tuning_parameters
|
||||
*
|
||||
* Gets the parameters to customize the NOx algorithm.
|
||||
*
|
||||
* @param[out] index_offset NOx index representing typical (average) conditions.
|
||||
* @param[out] learning_time_offset_hours Time constant to estimate the NOx
|
||||
* algorithm offset from the history in hours. Past events will be forgotten
|
||||
* after about twice the learning time.
|
||||
* @param[out] learning_time_gain_hours The time constant to estimate the NOx
|
||||
* algorithm gain from the history has no impact for NOx. This parameter is
|
||||
* still in place for consistency reasons with the VOC tuning parameters
|
||||
* command.
|
||||
* @param[out] gating_max_duration_minutes Maximum duration of gating in minutes
|
||||
* (freeze of estimator during high NOx index signal). Zero disables the gating.
|
||||
* @param[out] std_initial The initial estimate for standard deviation has no
|
||||
* impact for NOx. This parameter is still in place for consistency reasons with
|
||||
* the VOC tuning parameters command.
|
||||
* @param[out] gain_factor Gain factor to amplify or to attenuate the NOx index
|
||||
* output.
|
||||
*
|
||||
* @note This command is available only in idle mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_nox_algorithm_tuning_parameters(
|
||||
int16_t* index_offset, int16_t* learning_time_offset_hours,
|
||||
int16_t* learning_time_gain_hours, int16_t* gating_max_duration_minutes,
|
||||
int16_t* std_initial, int16_t* gain_factor);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_nox_algorithm_tuning_parameters
|
||||
*
|
||||
* Sets the parameters to customize the NOx algorithm. This configuration is
|
||||
* volatile, i.e. the parameters will be reverted to their default values after
|
||||
* a device reset.
|
||||
*
|
||||
* @param[in] index_offset NOx index representing typical (average) conditions.
|
||||
* Allowed values are in range 1..250. The default value is 1.
|
||||
* @param[in] learning_time_offset_hours Time constant to estimate the NOx
|
||||
* algorithm offset from the history in hours. Past events will be forgotten
|
||||
* after about twice the learning time. Allowed values are in range 1..1000. The
|
||||
* default value is 12 hours.
|
||||
* @param[in] learning_time_gain_hours The time constant to estimate the NOx
|
||||
* algorithm gain from the history has no impact for NOx. This parameter is
|
||||
* still in place for consistency reasons with the VOC tuning parameters
|
||||
* command. This parameter must always be set to 12 hours.
|
||||
* @param[in] gating_max_duration_minutes Maximum duration of gating in minutes
|
||||
* (freeze of estimator during high NOx index signal). Set to zero to disable
|
||||
* the gating. Allowed values are in range 0..3000. The default value is 720
|
||||
* minutes.
|
||||
* @param[in] std_initial The initial estimate for standard deviation parameter
|
||||
* has no impact for NOx. This parameter is still in place for consistency
|
||||
* reasons with the VOC tuning parameters command. This parameter must always be
|
||||
* set to 50.
|
||||
* @param[in] gain_factor Gain factor to amplify or to attenuate the NOx index
|
||||
* output. Allowed values are in range 1..1000. The default value is 230.
|
||||
*
|
||||
* @note This command is available only in idle mode. In measure mode, this
|
||||
* command has no effect. In addition, it has no effect if at least one
|
||||
* parameter is outside the specified range.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*
|
||||
* Example:
|
||||
* --------
|
||||
*
|
||||
* @code{.c}
|
||||
*
|
||||
* int16_t local_error = 0;
|
||||
*
|
||||
* local_error = sen66_set_nox_algorithm_tuning_parameters(1, 12, 12, 720,
|
||||
* 50, 230); if (local_error != NO_ERROR) { return local_error;
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*
|
||||
*/
|
||||
int16_t sen66_set_nox_algorithm_tuning_parameters(
|
||||
int16_t index_offset, int16_t learning_time_offset_hours,
|
||||
int16_t learning_time_gain_hours, int16_t gating_max_duration_minutes,
|
||||
int16_t std_initial, int16_t gain_factor);
|
||||
|
||||
/**
|
||||
* @brief Perform Forced CO₂ Recalibration
|
||||
*
|
||||
* Execute the forced recalibration (FRC) of the CO₂. See the datasheet of the
|
||||
* SCD4x sensor for details how the forced recalibration shall be used.
|
||||
*
|
||||
* @param[in] target_co2_concentration Target CO₂ concentration [ppm] of the
|
||||
* test setup.
|
||||
* @param[out] correction Correction value as received from the SCD [ppm CO₂].
|
||||
* FRC correction [ppm CO₂] is calculated as follows: FRC = return_value -
|
||||
* 0x8000 If the recalibration has failed this returned value is 0xFFFF.
|
||||
*
|
||||
* @note After power-on wait at least 1000 ms and after stopping a measurement
|
||||
* 600 ms before sending this command. This command is not available in measure
|
||||
* mode. The recalibration procedure will take about 500 ms to complete, during
|
||||
* which time no other functions can be executed. This configuration is
|
||||
* persistent, i.e. the parameters will be retained during a device reset or
|
||||
* power cycle.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t
|
||||
sen66_perform_forced_co2_recalibration(uint16_t target_co2_concentration,
|
||||
uint16_t* correction);
|
||||
|
||||
/**
|
||||
* @brief Perform CO₂ Sensor Factory Reset
|
||||
*
|
||||
* This command resets all CO₂ sensor configuration settings stored in the
|
||||
* EEPROM and erases the FRC and ASC algorithm history of the CO₂ sensor. The
|
||||
* configuration settings are CO₂ sensor temperature offset (cannot be modified
|
||||
* over I2C interface), sensor altitude and the ASC enabled/disabled parameters
|
||||
* which are by default stored in the volatile memory (RAM). This command is
|
||||
* only available in idle mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_perform_co2_sensor_factory_reset(void);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_co2_sensor_automatic_self_calibration
|
||||
*
|
||||
* The CO₂ sensor supports automatic self calibration (ASC) for long-term
|
||||
* stability of the CO₂ output. This feature can be enabled or disabled. By
|
||||
* default it is enabled.
|
||||
*
|
||||
* @param[out] padding Padding byte, always 0x00.
|
||||
* @param[out] status Is set true (0x01) if the automatic self calibration is
|
||||
* enabled or false (0x00) if the automatic self calibration is disabled.
|
||||
*
|
||||
* @note This command is only available in idle mode. This configuration is
|
||||
* persistent, i.e. the status will be retained during a device reset or power
|
||||
* cycle.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_co2_sensor_automatic_self_calibration(uint8_t* padding,
|
||||
bool* status);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_co2_sensor_automatic_self_calibration
|
||||
*
|
||||
* Sets the status of the CO₂ sensor automatic self-calibration (ASC). The CO₂
|
||||
* sensor supports automatic self calibration (ASC) for long-term stability of
|
||||
* the CO₂ output. This feature can be enabled or disabled. By default it is
|
||||
* enabled.
|
||||
*
|
||||
* @param[in] status Set to true (0x0001) to enable or false (0x0000) to disable
|
||||
* the automatic CO₂ measurement self calibration feature. High byte of uint16
|
||||
* is padding and always 0x00.
|
||||
*
|
||||
* @note This command is only available in idle mode. This configuration is
|
||||
* persistent, i.e. the status will be retained during a device reset or power
|
||||
* cycle.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*
|
||||
* Example:
|
||||
* --------
|
||||
*
|
||||
* @code{.c}
|
||||
*
|
||||
* int16_t local_error = 0;
|
||||
*
|
||||
* local_error = sen66_set_co2_sensor_automatic_self_calibration(0);
|
||||
* if (local_error != NO_ERROR) {
|
||||
* return local_error;
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*
|
||||
*/
|
||||
int16_t sen66_set_co2_sensor_automatic_self_calibration(uint16_t status);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_ambient_pressure
|
||||
*
|
||||
* Gets the ambient pressure value. The ambient pressure can be used for
|
||||
* pressure compensation in the CO₂ sensor.
|
||||
*
|
||||
* @param[out] ambient_pressure Currently used ambient pressure [hPa] for
|
||||
* pressure compensation.
|
||||
*
|
||||
* @note This command can be used in any state of the device, i.e. both in idle
|
||||
* mode and in measure mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_ambient_pressure(uint16_t* ambient_pressure);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_ambient_pressure
|
||||
*
|
||||
* The ambient pressure can be used for pressure compensation in the CO₂ sensor.
|
||||
* Setting an ambient pressure overrides any pressure compensation based on a
|
||||
* previously set sensor altitude. Use of this command is recommended for
|
||||
* applications experiencing significant ambient pressure changes to ensure CO₂
|
||||
* sensor accuracy. Valid input values are between 700 to 1'200 hPa. The default
|
||||
* value is 1013 hPa. This configuration is volatile, i.e. the parameter will be
|
||||
* reverted to its default value after a device restart.
|
||||
*
|
||||
* @param[in] ambient_pressure Ambient pressure [hPa] to be used for pressure
|
||||
* compensation.
|
||||
*
|
||||
* @note This command can be used in any state of the device, i.e. both in idle
|
||||
* mode and in measure mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*
|
||||
* Example:
|
||||
* --------
|
||||
*
|
||||
* @code{.c}
|
||||
*
|
||||
* int16_t local_error = 0;
|
||||
*
|
||||
* local_error = sen66_set_ambient_pressure(1013);
|
||||
* if (local_error != NO_ERROR) {
|
||||
* return local_error;
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*
|
||||
*/
|
||||
int16_t sen66_set_ambient_pressure(uint16_t ambient_pressure);
|
||||
|
||||
/**
|
||||
* @brief sen66_get_sensor_altitude
|
||||
*
|
||||
* Gets the current sensor altitude. The sensor altitude can be used for
|
||||
* pressure compensation in the CO₂ sensor.
|
||||
*
|
||||
* @param[out] altitude Current sensor altitude [m].
|
||||
*
|
||||
* @note This command is only available in idle mode.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_sensor_altitude(uint16_t* altitude);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_sensor_altitude
|
||||
*
|
||||
* The sensor altitude can be used for pressure compensation in the CO₂ sensor.
|
||||
* The default sensor altitude value is set to 0 meters above sea level. Valid
|
||||
* input values are between 0 and 3000m. This configuration is volatile, i.e.
|
||||
* the parameter will be reverted to its default value after a device reset.
|
||||
*
|
||||
* @param[in] altitude Sensor altitude [m], valid input between 0 and 3000m.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*
|
||||
* Example:
|
||||
* --------
|
||||
*
|
||||
* @code{.c}
|
||||
*
|
||||
* int16_t local_error = 0;
|
||||
*
|
||||
* local_error = sen66_set_sensor_altitude(0);
|
||||
* if (local_error != NO_ERROR) {
|
||||
* return local_error;
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*
|
||||
*/
|
||||
int16_t sen66_set_sensor_altitude(uint16_t altitude);
|
||||
|
||||
/**
|
||||
* @brief Start a continuous measurement (interval 1s)
|
||||
*
|
||||
* Starts a continuous measurement. After starting the measurement, it takes
|
||||
* some time (~1.1s) until the first measurement results are available. You
|
||||
* could poll with the command "Get Data Ready" to check when the results are
|
||||
* ready to read. This command is only available in idle mode. If the device is
|
||||
* already in any measure mode, this command has no effect.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_start_continuous_measurement(void);
|
||||
|
||||
/**
|
||||
* @brief Stop the continuous measurement
|
||||
*
|
||||
* Stops the measurement and returns to idle mode. After sending this command,
|
||||
* wait at least 1000 ms before starting a new measurement. If the device is
|
||||
* already in idle mode, this command has no effect.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_stop_measurement(void);
|
||||
|
||||
/**
|
||||
* @brief Check if data is ready to be read out from the sensor
|
||||
*
|
||||
* This command can be used to check if new measurement results are ready to
|
||||
* read. The data ready flag is automatically reset after reading the
|
||||
* measurement values.
|
||||
*
|
||||
* @param[out] padding Padding byte, always 0x00.
|
||||
* @param[out] data_ready True (0x01) if data is ready, False (0x00) if not.
|
||||
* When no measurement is running, False will be returned.
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_get_data_ready(uint8_t* padding, bool* data_ready);
|
||||
|
||||
/**
|
||||
* @brief sen66_read_number_concentration_values_as_integers
|
||||
*
|
||||
* Returns the measured number concentration values. The command 0x0202 "Get
|
||||
* Data Ready" can be used to check if new data is available since the last read
|
||||
* operation. If no new data is available, the previous values will be returned
|
||||
* again. If no data is available at all (e.g. measurement not running for at
|
||||
* least one second), all values will be at their upper limit (0xFFFF for
|
||||
* uint16).
|
||||
*
|
||||
* @param[out] number_concentration_pm0p5 Value is scaled with factor 10: PM0.5
|
||||
* [particles/cm³] = value / 10. *Note: If this value is unknown, 0xFFFF is
|
||||
* returned.*
|
||||
* @param[out] number_concentration_pm1p0 Value is scaled with factor 10: PM1.0
|
||||
* [particles/cm³] = value / 10. *Note: If this value is unknown, 0xFFFF is
|
||||
* returned.*
|
||||
* @param[out] number_concentration_pm2p5 Value is scaled with factor 10: PM2.5
|
||||
* [particles/cm³] = value / 10. *Note: If this value is unknown, 0xFFFF is
|
||||
* returned.*
|
||||
* @param[out] number_concentration_pm4p0 Value is scaled with factor 10: PM4.0
|
||||
* [particles/cm³] = value / 10. *Note: If this value is unknown, 0xFFFF is
|
||||
* returned.*
|
||||
* @param[out] number_concentration_pm10p0 Value is scaled with factor 10:
|
||||
* PM10.0 [particles/cm³] = value / 10. *Note: If this value is unknown, 0xFFFF
|
||||
* is returned.*
|
||||
*
|
||||
* @return error_code 0 on success, an error code otherwise.
|
||||
*/
|
||||
int16_t sen66_read_number_concentration_values_as_integers(
|
||||
uint16_t* number_concentration_pm0p5, uint16_t* number_concentration_pm1p0,
|
||||
uint16_t* number_concentration_pm2p5, uint16_t* number_concentration_pm4p0,
|
||||
uint16_t* number_concentration_pm10p0);
|
||||
|
||||
/**
|
||||
* @brief sen66_set_temperature_offset_parameters
|
||||
*
|
||||
* This command allows to compensate temperature effects of the design-in at
|
||||
* customer side by applying custom temperature offsets to the ambient
|
||||
* temperature.
|
||||
*
|
||||
* The compensated ambient temperature is calculated as follows:
|
||||
*
|
||||
*
|
||||
* * T_Ambient_Compensated = T_Ambient + (slope * T_Ambient) + offset
|
||||
* Where | ||||