diff --git a/CODEOWNERS b/CODEOWNERS index aad7cc3a19..472e304fb0 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -78,6 +78,7 @@ esphome/components/rf_bridge/* @jesserockz esphome/components/rtttl/* @glmnet esphome/components/script/* @esphome/core esphome/components/sensor/* @esphome/core +esphome/components/sgp40/* @SenexCrenshaw esphome/components/shutdown/* @esphome/core esphome/components/sim800l/* @glmnet esphome/components/spi/* @esphome/core diff --git a/esphome/components/sgp40/__init__.py b/esphome/components/sgp40/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/esphome/components/sgp40/sensirion_voc_algorithm.cpp b/esphome/components/sgp40/sensirion_voc_algorithm.cpp new file mode 100644 index 0000000000..c82db2301a --- /dev/null +++ b/esphome/components/sgp40/sensirion_voc_algorithm.cpp @@ -0,0 +1,629 @@ + +#include "sensirion_voc_algorithm.h" + +namespace esphome { +namespace sgp40 { + +/* The VOC code were originally created by + * https://github.com/Sensirion/embedded-sgp + * The fixed point arithmetic parts of this code were originally created by + * https://github.com/PetteriAimonen/libfixmath + */ + +/*!< the maximum value of fix16_t */ +#define FIX16_MAXIMUM 0x7FFFFFFF +/*!< the minimum value of fix16_t */ +static const uint32_t FIX16_MINIMUM = 0x80000000; +/*!< the value used to indicate overflows when FIXMATH_NO_OVERFLOW is not + * specified */ +static const uint32_t FIX16_OVERFLOW = 0x80000000; +/*!< fix16_t value of 1 */ +const uint32_t FIX16_ONE = 0x00010000; + +inline fix16_t fix16_from_int(int32_t a) { return a * FIX16_ONE; } + +inline int32_t fix16_cast_to_int(fix16_t a) { return (a >> 16); } + +/*! Multiplies the two given fix16_t's and returns the result. */ +static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1); + +/*! Divides the first given fix16_t by the second and returns the result. */ +static fix16_t fix16_div(fix16_t a, fix16_t b); + +/*! Returns the square root of the given fix16_t. */ +static fix16_t fix16_sqrt(fix16_t in_value); + +/*! Returns the exponent (e^) of the given fix16_t. */ +static fix16_t fix16_exp(fix16_t in_value); + +static fix16_t fix16_mul(fix16_t in_arg0, fix16_t in_arg1) { + // Each argument is divided to 16-bit parts. + // AB + // * CD + // ----------- + // BD 16 * 16 -> 32 bit products + // CB + // AD + // AC + // |----| 64 bit product + int32_t a = (in_arg0 >> 16), c = (in_arg1 >> 16); + uint32_t b = (in_arg0 & 0xFFFF), d = (in_arg1 & 0xFFFF); + + int32_t ac = a * c; + int32_t ad_cb = a * d + c * b; + uint32_t bd = b * d; + + int32_t product_hi = ac + (ad_cb >> 16); // NOLINT + + // Handle carry from lower 32 bits to upper part of result. + uint32_t ad_cb_temp = ad_cb << 16; // NOLINT + uint32_t product_lo = bd + ad_cb_temp; + if (product_lo < bd) + product_hi++; + +#ifndef FIXMATH_NO_OVERFLOW + // The upper 17 bits should all be the same (the sign). + if (product_hi >> 31 != product_hi >> 15) + return FIX16_OVERFLOW; +#endif + +#ifdef FIXMATH_NO_ROUNDING + return (product_hi << 16) | (product_lo >> 16); +#else + // Subtracting 0x8000 (= 0.5) and then using signed right shift + // achieves proper rounding to result-1, except in the corner + // case of negative numbers and lowest word = 0x8000. + // To handle that, we also have to subtract 1 for negative numbers. + uint32_t product_lo_tmp = product_lo; + product_lo -= 0x8000; + product_lo -= (uint32_t) product_hi >> 31; + if (product_lo > product_lo_tmp) + product_hi--; + + // Discard the lowest 16 bits. Note that this is not exactly the same + // as dividing by 0x10000. For example if product = -1, result will + // also be -1 and not 0. This is compensated by adding +1 to the result + // and compensating this in turn in the rounding above. + fix16_t result = (product_hi << 16) | (product_lo >> 16); // NOLINT + result += 1; + return result; +#endif +} + +static fix16_t fix16_div(fix16_t a, fix16_t b) { + // This uses the basic binary restoring division algorithm. + // It appears to be faster to do the whole division manually than + // trying to compose a 64-bit divide out of 32-bit divisions on + // platforms without hardware divide. + + if (b == 0) + return FIX16_MINIMUM; + + uint32_t remainder = (a >= 0) ? a : (-a); + uint32_t divider = (b >= 0) ? b : (-b); + + uint32_t quotient = 0; + uint32_t bit = 0x10000; + + /* The algorithm requires D >= R */ + while (divider < remainder) { + divider <<= 1; + bit <<= 1; + } + +#ifndef FIXMATH_NO_OVERFLOW + if (!bit) + return FIX16_OVERFLOW; +#endif + + if (divider & 0x80000000) { + // Perform one step manually to avoid overflows later. + // We know that divider's bottom bit is 0 here. + if (remainder >= divider) { + quotient |= bit; + remainder -= divider; + } + divider >>= 1; + bit >>= 1; + } + + /* Main division loop */ + while (bit && remainder) { + if (remainder >= divider) { + quotient |= bit; + remainder -= divider; + } + + remainder <<= 1; + bit >>= 1; + } + +#ifndef FIXMATH_NO_ROUNDING + if (remainder >= divider) { + quotient++; + } +#endif + + fix16_t result = quotient; + + /* Figure out the sign of result */ + if ((a ^ b) & 0x80000000) { +#ifndef FIXMATH_NO_OVERFLOW + if (result == FIX16_MINIMUM) + return FIX16_OVERFLOW; +#endif + + result = -result; + } + + return result; +} + +static fix16_t fix16_sqrt(fix16_t in_value) { + // It is assumed that x is not negative + + uint32_t num = in_value; + uint32_t result = 0; + uint32_t bit; + uint8_t n; + + bit = (uint32_t) 1 << 30; + while (bit > num) + bit >>= 2; + + // The main part is executed twice, in order to avoid + // using 64 bit values in computations. + for (n = 0; n < 2; n++) { + // First we get the top 24 bits of the answer. + while (bit) { + if (num >= result + bit) { + num -= result + bit; + result = (result >> 1) + bit; + } else { + result = (result >> 1); + } + bit >>= 2; + } + + if (n == 0) { + // Then process it again to get the lowest 8 bits. + if (num > 65535) { + // The remainder 'num' is too large to be shifted left + // by 16, so we have to add 1 to result manually and + // adjust 'num' accordingly. + // num = a - (result + 0.5)^2 + // = num + result^2 - (result + 0.5)^2 + // = num - result - 0.5 + num -= result; + num = (num << 16) - 0x8000; + result = (result << 16) + 0x8000; + } else { + num <<= 16; + result <<= 16; + } + + bit = 1 << 14; + } + } + +#ifndef FIXMATH_NO_ROUNDING + // Finally, if next bit would have been 1, round the result upwards. + if (num > result) { + result++; + } +#endif + + return (fix16_t) result; +} + +static fix16_t fix16_exp(fix16_t in_value) { + // Function to approximate exp(); optimized more for code size than speed + + // exp(x) for x = +/- {1, 1/8, 1/64, 1/512} + fix16_t x = in_value; + static const uint8_t NUM_EXP_VALUES = 4; + static const fix16_t EXP_POS_VALUES[4] = {F16(2.7182818), F16(1.1331485), F16(1.0157477), F16(1.0019550)}; + static const fix16_t EXP_NEG_VALUES[4] = {F16(0.3678794), F16(0.8824969), F16(0.9844964), F16(0.9980488)}; + const fix16_t* exp_values; + + fix16_t res, arg; + uint16_t i; + + if (x >= F16(10.3972)) + return FIX16_MAXIMUM; + if (x <= F16(-11.7835)) + return 0; + + if (x < 0) { + x = -x; + exp_values = EXP_NEG_VALUES; + } else { + exp_values = EXP_POS_VALUES; + } + + res = FIX16_ONE; + arg = FIX16_ONE; + for (i = 0; i < NUM_EXP_VALUES; i++) { + while (x >= arg) { + res = fix16_mul(res, exp_values[i]); + x -= arg; + } + arg >>= 3; + } + return res; +} + +static void voc_algorithm_init_instances(VocAlgorithmParams* params); +static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams* params); +static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams* params); +static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams* params, fix16_t std_initial, + fix16_t tau_mean_variance_hours, + fix16_t gating_max_duration_minutes); +static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams* params, fix16_t mean, fix16_t std, + fix16_t uptime_gamma); +static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams* params); +static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams* params); +static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams* params, + fix16_t voc_index_from_prior); +static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams* params, fix16_t sraw, + fix16_t voc_index_from_prior); +static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams* params); +static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams* params, fix16_t l, + fix16_t x0, fix16_t k); +static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams* params, fix16_t sample); +static void voc_algorithm_mox_model_init(VocAlgorithmParams* params); +static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams* params, fix16_t sraw_std, fix16_t sraw_mean); +static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams* params, fix16_t sraw); +static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams* params); +static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams* params, fix16_t offset); +static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams* params, fix16_t sample); +static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams* params); +static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams* params); +static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams* params, fix16_t sample); + +void voc_algorithm_init(VocAlgorithmParams* params) { + params->mVoc_Index_Offset = F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT); + params->mTau_Mean_Variance_Hours = F16(VOC_ALGORITHM_TAU_MEAN_VARIANCE_HOURS); + params->mGating_Max_Duration_Minutes = F16(VOC_ALGORITHM_GATING_MAX_DURATION_MINUTES); + params->mSraw_Std_Initial = F16(VOC_ALGORITHM_SRAW_STD_INITIAL); + params->mUptime = F16(0.); + params->mSraw = F16(0.); + params->mVoc_Index = 0; + voc_algorithm_init_instances(params); +} + +static void voc_algorithm_init_instances(VocAlgorithmParams* params) { + voc_algorithm_mean_variance_estimator_init(params); + voc_algorithm_mean_variance_estimator_set_parameters( + params, params->mSraw_Std_Initial, params->mTau_Mean_Variance_Hours, params->mGating_Max_Duration_Minutes); + voc_algorithm_mox_model_init(params); + voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params), + voc_algorithm_mean_variance_estimator_get_mean(params)); + voc_algorithm_sigmoid_scaled_init(params); + voc_algorithm_sigmoid_scaled_set_parameters(params, params->mVoc_Index_Offset); + voc_algorithm_adaptive_lowpass_init(params); + voc_algorithm_adaptive_lowpass_set_parameters(params); +} + +void voc_algorithm_get_states(VocAlgorithmParams* params, int32_t* state0, int32_t* state1) { + *state0 = voc_algorithm_mean_variance_estimator_get_mean(params); + *state1 = voc_algorithm_mean_variance_estimator_get_std(params); +} + +void voc_algorithm_set_states(VocAlgorithmParams* params, int32_t state0, int32_t state1) { + voc_algorithm_mean_variance_estimator_set_states(params, state0, state1, F16(VOC_ALGORITHM_PERSISTENCE_UPTIME_GAMMA)); + params->mSraw = state0; +} + +void voc_algorithm_set_tuning_parameters(VocAlgorithmParams* params, int32_t voc_index_offset, + int32_t learning_time_hours, int32_t gating_max_duration_minutes, + int32_t std_initial) { + params->mVoc_Index_Offset = (fix16_from_int(voc_index_offset)); + params->mTau_Mean_Variance_Hours = (fix16_from_int(learning_time_hours)); + params->mGating_Max_Duration_Minutes = (fix16_from_int(gating_max_duration_minutes)); + params->mSraw_Std_Initial = (fix16_from_int(std_initial)); + voc_algorithm_init_instances(params); +} + +void voc_algorithm_process(VocAlgorithmParams* params, int32_t sraw, int32_t* voc_index) { + if ((params->mUptime <= F16(VOC_ALGORITHM_INITIAL_BLACKOUT))) { + params->mUptime = (params->mUptime + F16(VOC_ALGORITHM_SAMPLING_INTERVAL)); + } else { + if (((sraw > 0) && (sraw < 65000))) { + if ((sraw < 20001)) { + sraw = 20001; + } else if ((sraw > 52767)) { + sraw = 52767; + } + params->mSraw = (fix16_from_int((sraw - 20000))); + } + params->mVoc_Index = voc_algorithm_mox_model_process(params, params->mSraw); + params->mVoc_Index = voc_algorithm_sigmoid_scaled_process(params, params->mVoc_Index); + params->mVoc_Index = voc_algorithm_adaptive_lowpass_process(params, params->mVoc_Index); + if ((params->mVoc_Index < F16(0.5))) { + params->mVoc_Index = F16(0.5); + } + if ((params->mSraw > F16(0.))) { + voc_algorithm_mean_variance_estimator_process(params, params->mSraw, params->mVoc_Index); + voc_algorithm_mox_model_set_parameters(params, voc_algorithm_mean_variance_estimator_get_std(params), + voc_algorithm_mean_variance_estimator_get_mean(params)); + } + } + *voc_index = (fix16_cast_to_int((params->mVoc_Index + F16(0.5)))); +} + +static void voc_algorithm_mean_variance_estimator_init(VocAlgorithmParams* params) { + voc_algorithm_mean_variance_estimator_set_parameters(params, F16(0.), F16(0.), F16(0.)); + voc_algorithm_mean_variance_estimator_init_instances(params); +} + +static void voc_algorithm_mean_variance_estimator_init_instances(VocAlgorithmParams* params) { + voc_algorithm_mean_variance_estimator_sigmoid_init(params); +} + +static void voc_algorithm_mean_variance_estimator_set_parameters(VocAlgorithmParams* params, fix16_t std_initial, + fix16_t tau_mean_variance_hours, + fix16_t gating_max_duration_minutes) { + params->m_Mean_Variance_Estimator__Gating_Max_Duration_Minutes = gating_max_duration_minutes; + params->m_Mean_Variance_Estimator___Initialized = false; + params->m_Mean_Variance_Estimator___Mean = F16(0.); + params->m_Mean_Variance_Estimator___Sraw_Offset = F16(0.); + params->m_Mean_Variance_Estimator___Std = std_initial; + params->m_Mean_Variance_Estimator___Gamma = + (fix16_div(F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * (VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.))), + (tau_mean_variance_hours + F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 3600.))))); + params->m_Mean_Variance_Estimator___Gamma_Initial_Mean = + F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) / + (VOC_ALGORITHM_TAU_INITIAL_MEAN + VOC_ALGORITHM_SAMPLING_INTERVAL))); + params->m_Mean_Variance_Estimator___Gamma_Initial_Variance = + F16(((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * VOC_ALGORITHM_SAMPLING_INTERVAL) / + (VOC_ALGORITHM_TAU_INITIAL_VARIANCE + VOC_ALGORITHM_SAMPLING_INTERVAL))); + params->m_Mean_Variance_Estimator__Gamma_Mean = F16(0.); + params->m_Mean_Variance_Estimator__Gamma_Variance = F16(0.); + params->m_Mean_Variance_Estimator___Uptime_Gamma = F16(0.); + params->m_Mean_Variance_Estimator___Uptime_Gating = F16(0.); + params->m_Mean_Variance_Estimator___Gating_Duration_Minutes = F16(0.); +} + +static void voc_algorithm_mean_variance_estimator_set_states(VocAlgorithmParams* params, fix16_t mean, fix16_t std, + fix16_t uptime_gamma) { + params->m_Mean_Variance_Estimator___Mean = mean; + params->m_Mean_Variance_Estimator___Std = std; + params->m_Mean_Variance_Estimator___Uptime_Gamma = uptime_gamma; + params->m_Mean_Variance_Estimator___Initialized = true; +} + +static fix16_t voc_algorithm_mean_variance_estimator_get_std(VocAlgorithmParams* params) { + return params->m_Mean_Variance_Estimator___Std; +} + +static fix16_t voc_algorithm_mean_variance_estimator_get_mean(VocAlgorithmParams* params) { + return (params->m_Mean_Variance_Estimator___Mean + params->m_Mean_Variance_Estimator___Sraw_Offset); +} + +static void voc_algorithm_mean_variance_estimator_calculate_gamma(VocAlgorithmParams* params, + fix16_t voc_index_from_prior) { + fix16_t uptime_limit; + fix16_t sigmoid_gamma_mean; + fix16_t gamma_mean; + fix16_t gating_threshold_mean; + fix16_t sigmoid_gating_mean; + fix16_t sigmoid_gamma_variance; + fix16_t gamma_variance; + fix16_t gating_threshold_variance; + fix16_t sigmoid_gating_variance; + + uptime_limit = F16((VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_FI_X16_MAX - VOC_ALGORITHM_SAMPLING_INTERVAL)); + if ((params->m_Mean_Variance_Estimator___Uptime_Gamma < uptime_limit)) { + params->m_Mean_Variance_Estimator___Uptime_Gamma = + (params->m_Mean_Variance_Estimator___Uptime_Gamma + F16(VOC_ALGORITHM_SAMPLING_INTERVAL)); + } + if ((params->m_Mean_Variance_Estimator___Uptime_Gating < uptime_limit)) { + params->m_Mean_Variance_Estimator___Uptime_Gating = + (params->m_Mean_Variance_Estimator___Uptime_Gating + F16(VOC_ALGORITHM_SAMPLING_INTERVAL)); + } + voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_MEAN), + F16(VOC_ALGORITHM_INIT_TRANSITION_MEAN)); + sigmoid_gamma_mean = + voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator___Uptime_Gamma); + gamma_mean = + (params->m_Mean_Variance_Estimator___Gamma + + (fix16_mul((params->m_Mean_Variance_Estimator___Gamma_Initial_Mean - params->m_Mean_Variance_Estimator___Gamma), + sigmoid_gamma_mean))); + gating_threshold_mean = (F16(VOC_ALGORITHM_GATING_THRESHOLD) + + (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)), + voc_algorithm_mean_variance_estimator_sigmoid_process( + params, params->m_Mean_Variance_Estimator___Uptime_Gating)))); + voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_mean, + F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION)); + sigmoid_gating_mean = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior); + params->m_Mean_Variance_Estimator__Gamma_Mean = (fix16_mul(sigmoid_gating_mean, gamma_mean)); + voc_algorithm_mean_variance_estimator_sigmoid_set_parameters( + params, F16(1.), F16(VOC_ALGORITHM_INIT_DURATION_VARIANCE), F16(VOC_ALGORITHM_INIT_TRANSITION_VARIANCE)); + sigmoid_gamma_variance = + voc_algorithm_mean_variance_estimator_sigmoid_process(params, params->m_Mean_Variance_Estimator___Uptime_Gamma); + gamma_variance = (params->m_Mean_Variance_Estimator___Gamma + + (fix16_mul((params->m_Mean_Variance_Estimator___Gamma_Initial_Variance - + params->m_Mean_Variance_Estimator___Gamma), + (sigmoid_gamma_variance - sigmoid_gamma_mean)))); + gating_threshold_variance = + (F16(VOC_ALGORITHM_GATING_THRESHOLD) + + (fix16_mul(F16((VOC_ALGORITHM_GATING_THRESHOLD_INITIAL - VOC_ALGORITHM_GATING_THRESHOLD)), + voc_algorithm_mean_variance_estimator_sigmoid_process( + params, params->m_Mean_Variance_Estimator___Uptime_Gating)))); + voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(1.), gating_threshold_variance, + F16(VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION)); + sigmoid_gating_variance = voc_algorithm_mean_variance_estimator_sigmoid_process(params, voc_index_from_prior); + params->m_Mean_Variance_Estimator__Gamma_Variance = (fix16_mul(sigmoid_gating_variance, gamma_variance)); + params->m_Mean_Variance_Estimator___Gating_Duration_Minutes = + (params->m_Mean_Variance_Estimator___Gating_Duration_Minutes + + (fix16_mul(F16((VOC_ALGORITHM_SAMPLING_INTERVAL / 60.)), + ((fix16_mul((F16(1.) - sigmoid_gating_mean), F16((1. + VOC_ALGORITHM_GATING_MAX_RATIO)))) - + F16(VOC_ALGORITHM_GATING_MAX_RATIO))))); + if ((params->m_Mean_Variance_Estimator___Gating_Duration_Minutes < F16(0.))) { + params->m_Mean_Variance_Estimator___Gating_Duration_Minutes = F16(0.); + } + if ((params->m_Mean_Variance_Estimator___Gating_Duration_Minutes > + params->m_Mean_Variance_Estimator__Gating_Max_Duration_Minutes)) { + params->m_Mean_Variance_Estimator___Uptime_Gating = F16(0.); + } +} + +static void voc_algorithm_mean_variance_estimator_process(VocAlgorithmParams* params, fix16_t sraw, + fix16_t voc_index_from_prior) { + fix16_t delta_sgp; + fix16_t c; + fix16_t additional_scaling; + + if ((!params->m_Mean_Variance_Estimator___Initialized)) { + params->m_Mean_Variance_Estimator___Initialized = true; + params->m_Mean_Variance_Estimator___Sraw_Offset = sraw; + params->m_Mean_Variance_Estimator___Mean = F16(0.); + } else { + if (((params->m_Mean_Variance_Estimator___Mean >= F16(100.)) || + (params->m_Mean_Variance_Estimator___Mean <= F16(-100.)))) { + params->m_Mean_Variance_Estimator___Sraw_Offset = + (params->m_Mean_Variance_Estimator___Sraw_Offset + params->m_Mean_Variance_Estimator___Mean); + params->m_Mean_Variance_Estimator___Mean = F16(0.); + } + sraw = (sraw - params->m_Mean_Variance_Estimator___Sraw_Offset); + voc_algorithm_mean_variance_estimator_calculate_gamma(params, voc_index_from_prior); + delta_sgp = (fix16_div((sraw - params->m_Mean_Variance_Estimator___Mean), + F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING))); + if ((delta_sgp < F16(0.))) { + c = (params->m_Mean_Variance_Estimator___Std - delta_sgp); + } else { + c = (params->m_Mean_Variance_Estimator___Std + delta_sgp); + } + additional_scaling = F16(1.); + if ((c > F16(1440.))) { + additional_scaling = F16(4.); + } + params->m_Mean_Variance_Estimator___Std = (fix16_mul( + fix16_sqrt((fix16_mul(additional_scaling, (F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) - + params->m_Mean_Variance_Estimator__Gamma_Variance)))), + fix16_sqrt(((fix16_mul(params->m_Mean_Variance_Estimator___Std, + (fix16_div(params->m_Mean_Variance_Estimator___Std, + (fix16_mul(F16(VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING), + additional_scaling)))))) + + (fix16_mul((fix16_div((fix16_mul(params->m_Mean_Variance_Estimator__Gamma_Variance, delta_sgp)), + additional_scaling)), + delta_sgp)))))); + params->m_Mean_Variance_Estimator___Mean = (params->m_Mean_Variance_Estimator___Mean + + (fix16_mul(params->m_Mean_Variance_Estimator__Gamma_Mean, delta_sgp))); + } +} + +static void voc_algorithm_mean_variance_estimator_sigmoid_init(VocAlgorithmParams* params) { + voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(params, F16(0.), F16(0.), F16(0.)); +} + +static void voc_algorithm_mean_variance_estimator_sigmoid_set_parameters(VocAlgorithmParams* params, fix16_t l, + fix16_t x0, fix16_t k) { + params->m_Mean_Variance_Estimator___Sigmoid__L = l; + params->m_Mean_Variance_Estimator___Sigmoid__K = k; + params->m_Mean_Variance_Estimator___Sigmoid__X0 = x0; +} + +static fix16_t voc_algorithm_mean_variance_estimator_sigmoid_process(VocAlgorithmParams* params, fix16_t sample) { + fix16_t x; + + x = (fix16_mul(params->m_Mean_Variance_Estimator___Sigmoid__K, + (sample - params->m_Mean_Variance_Estimator___Sigmoid__X0))); + if ((x < F16(-50.))) { + return params->m_Mean_Variance_Estimator___Sigmoid__L; + } else if ((x > F16(50.))) { + return F16(0.); + } else { + return (fix16_div(params->m_Mean_Variance_Estimator___Sigmoid__L, (F16(1.) + fix16_exp(x)))); + } +} + +static void voc_algorithm_mox_model_init(VocAlgorithmParams* params) { + voc_algorithm_mox_model_set_parameters(params, F16(1.), F16(0.)); +} + +static void voc_algorithm_mox_model_set_parameters(VocAlgorithmParams* params, fix16_t sraw_std, fix16_t sraw_mean) { + params->m_Mox_Model__Sraw_Std = sraw_std; + params->m_Mox_Model__Sraw_Mean = sraw_mean; +} + +static fix16_t voc_algorithm_mox_model_process(VocAlgorithmParams* params, fix16_t sraw) { + return (fix16_mul((fix16_div((sraw - params->m_Mox_Model__Sraw_Mean), + (-(params->m_Mox_Model__Sraw_Std + F16(VOC_ALGORITHM_SRAW_STD_BONUS))))), + F16(VOC_ALGORITHM_VOC_INDEX_GAIN))); +} + +static void voc_algorithm_sigmoid_scaled_init(VocAlgorithmParams* params) { + voc_algorithm_sigmoid_scaled_set_parameters(params, F16(0.)); +} + +static void voc_algorithm_sigmoid_scaled_set_parameters(VocAlgorithmParams* params, fix16_t offset) { + params->m_Sigmoid_Scaled__Offset = offset; +} + +static fix16_t voc_algorithm_sigmoid_scaled_process(VocAlgorithmParams* params, fix16_t sample) { + fix16_t x; + fix16_t shift; + + x = (fix16_mul(F16(VOC_ALGORITHM_SIGMOID_K), (sample - F16(VOC_ALGORITHM_SIGMOID_X0)))); + if ((x < F16(-50.))) { + return F16(VOC_ALGORITHM_SIGMOID_L); + } else if ((x > F16(50.))) { + return F16(0.); + } else { + if ((sample >= F16(0.))) { + shift = + (fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) - (fix16_mul(F16(5.), params->m_Sigmoid_Scaled__Offset))), F16(4.))); + return ((fix16_div((F16(VOC_ALGORITHM_SIGMOID_L) + shift), (F16(1.) + fix16_exp(x)))) - shift); + } else { + return (fix16_mul((fix16_div(params->m_Sigmoid_Scaled__Offset, F16(VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT))), + (fix16_div(F16(VOC_ALGORITHM_SIGMOID_L), (F16(1.) + fix16_exp(x)))))); + } + } +} + +static void voc_algorithm_adaptive_lowpass_init(VocAlgorithmParams* params) { + voc_algorithm_adaptive_lowpass_set_parameters(params); +} + +static void voc_algorithm_adaptive_lowpass_set_parameters(VocAlgorithmParams* params) { + params->m_Adaptive_Lowpass__A1 = + F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_FAST + VOC_ALGORITHM_SAMPLING_INTERVAL))); + params->m_Adaptive_Lowpass__A2 = + F16((VOC_ALGORITHM_SAMPLING_INTERVAL / (VOC_ALGORITHM_LP_TAU_SLOW + VOC_ALGORITHM_SAMPLING_INTERVAL))); + params->m_Adaptive_Lowpass___Initialized = false; +} + +static fix16_t voc_algorithm_adaptive_lowpass_process(VocAlgorithmParams* params, fix16_t sample) { + fix16_t abs_delta; + fix16_t f1; + fix16_t tau_a; + fix16_t a3; + + if ((!params->m_Adaptive_Lowpass___Initialized)) { + params->m_Adaptive_Lowpass___X1 = sample; + params->m_Adaptive_Lowpass___X2 = sample; + params->m_Adaptive_Lowpass___X3 = sample; + params->m_Adaptive_Lowpass___Initialized = true; + } + params->m_Adaptive_Lowpass___X1 = + ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass__A1), params->m_Adaptive_Lowpass___X1)) + + (fix16_mul(params->m_Adaptive_Lowpass__A1, sample))); + params->m_Adaptive_Lowpass___X2 = + ((fix16_mul((F16(1.) - params->m_Adaptive_Lowpass__A2), params->m_Adaptive_Lowpass___X2)) + + (fix16_mul(params->m_Adaptive_Lowpass__A2, sample))); + abs_delta = (params->m_Adaptive_Lowpass___X1 - params->m_Adaptive_Lowpass___X2); + if ((abs_delta < F16(0.))) { + abs_delta = (-abs_delta); + } + f1 = fix16_exp((fix16_mul(F16(VOC_ALGORITHM_LP_ALPHA), abs_delta))); + tau_a = + ((fix16_mul(F16((VOC_ALGORITHM_LP_TAU_SLOW - VOC_ALGORITHM_LP_TAU_FAST)), f1)) + F16(VOC_ALGORITHM_LP_TAU_FAST)); + a3 = (fix16_div(F16(VOC_ALGORITHM_SAMPLING_INTERVAL), (F16(VOC_ALGORITHM_SAMPLING_INTERVAL) + tau_a))); + params->m_Adaptive_Lowpass___X3 = + ((fix16_mul((F16(1.) - a3), params->m_Adaptive_Lowpass___X3)) + (fix16_mul(a3, sample))); + return params->m_Adaptive_Lowpass___X3; +} +} // namespace sgp40 +} // namespace esphome diff --git a/esphome/components/sgp40/sensirion_voc_algorithm.h b/esphome/components/sgp40/sensirion_voc_algorithm.h new file mode 100644 index 0000000000..05431635ad --- /dev/null +++ b/esphome/components/sgp40/sensirion_voc_algorithm.h @@ -0,0 +1,147 @@ +#pragma once +#include +namespace esphome { +namespace sgp40 { + +/* The VOC code were originally created by + * https://github.com/Sensirion/embedded-sgp + * The fixed point arithmetic parts of this code were originally created by + * https://github.com/PetteriAimonen/libfixmath + */ + +using fix16_t = int32_t; + +#define F16(x) ((fix16_t)(((x) >= 0) ? ((x) *65536.0 + 0.5) : ((x) *65536.0 - 0.5))) + +static const float VOC_ALGORITHM_SAMPLING_INTERVAL(1.); +static const float VOC_ALGORITHM_INITIAL_BLACKOUT(45.); +static const float VOC_ALGORITHM_VOC_INDEX_GAIN(230.); +static const float VOC_ALGORITHM_SRAW_STD_INITIAL(50.); +static const float VOC_ALGORITHM_SRAW_STD_BONUS(220.); +static const float VOC_ALGORITHM_TAU_MEAN_VARIANCE_HOURS(12.); +static const float VOC_ALGORITHM_TAU_INITIAL_MEAN(20.); +static const float VOC_ALGORITHM_INIT_DURATION_MEAN((3600. * 0.75)); +static const float VOC_ALGORITHM_INIT_TRANSITION_MEAN(0.01); +static const float VOC_ALGORITHM_TAU_INITIAL_VARIANCE(2500.); +static const float VOC_ALGORITHM_INIT_DURATION_VARIANCE((3600. * 1.45)); +static const float VOC_ALGORITHM_INIT_TRANSITION_VARIANCE(0.01); +static const float VOC_ALGORITHM_GATING_THRESHOLD(340.); +static const float VOC_ALGORITHM_GATING_THRESHOLD_INITIAL(510.); +static const float VOC_ALGORITHM_GATING_THRESHOLD_TRANSITION(0.09); +static const float VOC_ALGORITHM_GATING_MAX_DURATION_MINUTES((60. * 3.)); +static const float VOC_ALGORITHM_GATING_MAX_RATIO(0.3); +static const float VOC_ALGORITHM_SIGMOID_L(500.); +static const float VOC_ALGORITHM_SIGMOID_K(-0.0065); +static const float VOC_ALGORITHM_SIGMOID_X0(213.); +static const float VOC_ALGORITHM_VOC_INDEX_OFFSET_DEFAULT(100.); +static const float VOC_ALGORITHM_LP_TAU_FAST(20.0); +static const float VOC_ALGORITHM_LP_TAU_SLOW(500.0); +static const float VOC_ALGORITHM_LP_ALPHA(-0.2); +static const float VOC_ALGORITHM_PERSISTENCE_UPTIME_GAMMA((3. * 3600.)); +static const float VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING(64.); +static const float VOC_ALGORITHM_MEAN_VARIANCE_ESTIMATOR_FI_X16_MAX(32767.); + +/** + * Struct to hold all the states of the VOC algorithm. + */ +struct VocAlgorithmParams { + fix16_t mVoc_Index_Offset; + fix16_t mTau_Mean_Variance_Hours; + fix16_t mGating_Max_Duration_Minutes; + fix16_t mSraw_Std_Initial; + fix16_t mUptime; + fix16_t mSraw; + fix16_t mVoc_Index; + fix16_t m_Mean_Variance_Estimator__Gating_Max_Duration_Minutes; + bool m_Mean_Variance_Estimator___Initialized; + fix16_t m_Mean_Variance_Estimator___Mean; + fix16_t m_Mean_Variance_Estimator___Sraw_Offset; + fix16_t m_Mean_Variance_Estimator___Std; + fix16_t m_Mean_Variance_Estimator___Gamma; + fix16_t m_Mean_Variance_Estimator___Gamma_Initial_Mean; + fix16_t m_Mean_Variance_Estimator___Gamma_Initial_Variance; + fix16_t m_Mean_Variance_Estimator__Gamma_Mean; + fix16_t m_Mean_Variance_Estimator__Gamma_Variance; + fix16_t m_Mean_Variance_Estimator___Uptime_Gamma; + fix16_t m_Mean_Variance_Estimator___Uptime_Gating; + fix16_t m_Mean_Variance_Estimator___Gating_Duration_Minutes; + fix16_t m_Mean_Variance_Estimator___Sigmoid__L; + fix16_t m_Mean_Variance_Estimator___Sigmoid__K; + fix16_t m_Mean_Variance_Estimator___Sigmoid__X0; + fix16_t m_Mox_Model__Sraw_Std; + fix16_t m_Mox_Model__Sraw_Mean; + fix16_t m_Sigmoid_Scaled__Offset; + fix16_t m_Adaptive_Lowpass__A1; + fix16_t m_Adaptive_Lowpass__A2; + bool m_Adaptive_Lowpass___Initialized; + fix16_t m_Adaptive_Lowpass___X1; + fix16_t m_Adaptive_Lowpass___X2; + fix16_t m_Adaptive_Lowpass___X3; +}; + +/** + * Initialize the VOC algorithm parameters. Call this once at the beginning or + * whenever the sensor stopped measurements. + * @param params Pointer to the VocAlgorithmParams struct + */ +void voc_algorithm_init(VocAlgorithmParams *params); + +/** + * Get current algorithm states. Retrieved values can be used in + * voc_algorithm_set_states() to resume operation after a short interruption, + * skipping initial learning phase. This feature can only be used after at least + * 3 hours of continuous operation. + * @param params Pointer to the VocAlgorithmParams struct + * @param state0 State0 to be stored + * @param state1 State1 to be stored + */ +void voc_algorithm_get_states(VocAlgorithmParams *params, int32_t *state0, int32_t *state1); + +/** + * Set previously retrieved algorithm states to resume operation after a short + * interruption, skipping initial learning phase. This feature should not be + * used after inerruptions of more than 10 minutes. Call this once after + * voc_algorithm_init() and the optional voc_algorithm_set_tuning_parameters(), if + * desired. Otherwise, the algorithm will start with initial learning phase. + * @param params Pointer to the VocAlgorithmParams struct + * @param state0 State0 to be restored + * @param state1 State1 to be restored + */ +void voc_algorithm_set_states(VocAlgorithmParams *params, int32_t state0, int32_t state1); + +/** + * Set parameters to customize the VOC algorithm. Call this once after + * voc_algorithm_init(), if desired. Otherwise, the default values will be used. + * + * @param params Pointer to the VocAlgorithmParams struct + * @param voc_index_offset VOC index representing typical (average) + * conditions. Range 1..250, default 100 + * @param learning_time_hours Time constant of long-term estimator. + * Past events will be forgotten after about + * twice the learning time. + * Range 1..72 [hours], default 12 [hours] + * @param gating_max_duration_minutes Maximum duration of gating (freeze of + * estimator during high VOC index signal). + * 0 (no gating) or range 1..720 [minutes], + * default 180 [minutes] + * @param std_initial Initial estimate for standard deviation. + * Lower value boosts events during initial + * learning period, but may result in larger + * device-to-device variations. + * Range 10..500, default 50 + */ +void voc_algorithm_set_tuning_parameters(VocAlgorithmParams *params, int32_t voc_index_offset, + int32_t learning_time_hours, int32_t gating_max_duration_minutes, + int32_t std_initial); + +/** + * Calculate the VOC index value from the raw sensor value. + * + * @param params Pointer to the VocAlgorithmParams struct + * @param sraw Raw value from the SGP40 sensor + * @param voc_index Calculated VOC index value from the raw sensor value. Zero + * during initial blackout period and 1..500 afterwards + */ +void voc_algorithm_process(VocAlgorithmParams *params, int32_t sraw, int32_t *voc_index); +} // namespace sgp40 +} // namespace esphome diff --git a/esphome/components/sgp40/sensor.py b/esphome/components/sgp40/sensor.py new file mode 100644 index 0000000000..40bc07389b --- /dev/null +++ b/esphome/components/sgp40/sensor.py @@ -0,0 +1,57 @@ +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.components import i2c, sensor +from esphome.const import CONF_ID, DEVICE_CLASS_EMPTY, ICON_RADIATOR, UNIT_EMPTY + +DEPENDENCIES = ["i2c"] + +CODEOWNERS = ["@SenexCrenshaw"] + +sgp40_ns = cg.esphome_ns.namespace("sgp40") +SGP40Component = sgp40_ns.class_( + "SGP40Component", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice +) + +CONF_COMPENSATION = "compensation" +CONF_HUMIDITY_SOURCE = "humidity_source" +CONF_TEMPERATURE_SOURCE = "temperature_source" +CONF_STORE_BASELINE = "store_baseline" +CONF_VOC_BASELINE = "voc_baseline" + +CONFIG_SCHEMA = ( + sensor.sensor_schema(UNIT_EMPTY, ICON_RADIATOR, 0, DEVICE_CLASS_EMPTY) + .extend( + { + cv.GenerateID(): cv.declare_id(SGP40Component), + cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean, + cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t, + cv.Optional(CONF_COMPENSATION): cv.Schema( + { + cv.Required(CONF_HUMIDITY_SOURCE): cv.use_id(sensor.Sensor), + cv.Required(CONF_TEMPERATURE_SOURCE): cv.use_id(sensor.Sensor), + }, + ), + } + ) + .extend(cv.polling_component_schema("60s")) + .extend(i2c.i2c_device_schema(0x59)) +) + + +def to_code(config): + var = cg.new_Pvariable(config[CONF_ID]) + yield cg.register_component(var, config) + yield i2c.register_i2c_device(var, config) + yield sensor.register_sensor(var, config) + + if CONF_COMPENSATION in config: + compensation_config = config[CONF_COMPENSATION] + sens = yield cg.get_variable(compensation_config[CONF_HUMIDITY_SOURCE]) + cg.add(var.set_humidity_sensor(sens)) + sens = yield cg.get_variable(compensation_config[CONF_TEMPERATURE_SOURCE]) + cg.add(var.set_temperature_sensor(sens)) + + cg.add(var.set_store_baseline(config[CONF_STORE_BASELINE])) + + if CONF_VOC_BASELINE in config: + cg.add(var.set_voc_baseline(CONF_VOC_BASELINE)) diff --git a/esphome/components/sgp40/sgp40.cpp b/esphome/components/sgp40/sgp40.cpp new file mode 100644 index 0000000000..3e9f2b96cf --- /dev/null +++ b/esphome/components/sgp40/sgp40.cpp @@ -0,0 +1,314 @@ +#include "esphome/core/log.h" +#include "sgp40.h" + +namespace esphome { +namespace sgp40 { + +static const char *TAG = "sgp40"; + +void SGP40Component::setup() { + ESP_LOGCONFIG(TAG, "Setting up SGP40..."); + + // Serial Number identification + if (!this->write_command_(SGP40_CMD_GET_SERIAL_ID)) { + this->error_code_ = COMMUNICATION_FAILED; + this->mark_failed(); + return; + } + uint16_t raw_serial_number[3]; + + if (!this->read_data_(raw_serial_number, 3)) { + this->mark_failed(); + return; + } + this->serial_number_ = (uint64_t(raw_serial_number[0]) << 24) | (uint64_t(raw_serial_number[1]) << 16) | + (uint64_t(raw_serial_number[2])); + ESP_LOGD(TAG, "Serial Number: %llu", this->serial_number_); + + // Featureset identification for future use + if (!this->write_command_(SGP40_CMD_GET_FEATURESET)) { + ESP_LOGD(TAG, "raw_featureset write_command_ failed"); + this->mark_failed(); + return; + } + uint16_t raw_featureset[1]; + if (!this->read_data_(raw_featureset, 1)) { + ESP_LOGD(TAG, "raw_featureset read_data_ failed"); + this->mark_failed(); + return; + } + + this->featureset_ = raw_featureset[0]; + if ((this->featureset_ & 0x1FF) != SGP40_FEATURESET) { + ESP_LOGD(TAG, "Product feature set failed 0x%0X , expecting 0x%0X", uint16_t(this->featureset_ & 0x1FF), + SGP40_FEATURESET); + this->mark_failed(); + return; + } + + ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF)); + + voc_algorithm_init(&this->voc_algorithm_params_); + + if (this->store_baseline_) { + // Hash with compilation time + // This ensures the baseline storage is cleared after OTA + uint32_t hash = fnv1_hash(App.get_compilation_time()); + this->pref_ = global_preferences.make_preference(hash, true); + + if (this->pref_.load(&this->baselines_storage_)) { + this->state0_ = this->baselines_storage_.state0; + this->state1_ = this->baselines_storage_.state1; + ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04X, state1: 0x%04X", this->baselines_storage_.state0, + baselines_storage_.state1); + } + + // Initialize storage timestamp + this->seconds_since_last_store_ = 0; + + if (this->baselines_storage_.state0 > 0 && this->baselines_storage_.state1 > 0) { + ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04X, state1: 0x%04X", this->baselines_storage_.state0, + baselines_storage_.state1); + voc_algorithm_set_states(&this->voc_algorithm_params_, this->baselines_storage_.state0, + this->baselines_storage_.state1); + } + } + + this->self_test_(); +} + +void SGP40Component::self_test_() { + ESP_LOGD(TAG, "selfTest started"); + if (!this->write_command_(SGP40_CMD_SELF_TEST)) { + this->error_code_ = COMMUNICATION_FAILED; + ESP_LOGD(TAG, "selfTest communicatin failed"); + this->mark_failed(); + } + + this->set_timeout(250, [this]() { + uint16_t reply[1]; + if (!this->read_data_(reply, 1)) { + ESP_LOGD(TAG, "selfTest read_data_ failed"); + this->mark_failed(); + return; + } + + if (reply[0] == 0xD400) { + ESP_LOGD(TAG, "selfTest completed"); + return; + } + + ESP_LOGD(TAG, "selfTest failed"); + this->mark_failed(); + }); +} + +/** + * @brief Combined the measured gasses, temperature, and humidity + * to calculate the VOC Index + * + * @param temperature The measured temperature in degrees C + * @param humidity The measured relative humidity in % rH + * @return int32_t The VOC Index + */ +int32_t SGP40Component::measure_voc_index_() { + int32_t voc_index; + + uint16_t sraw = measure_raw_(); + + if (sraw == UINT16_MAX) + return UINT16_MAX; + + this->status_clear_warning(); + + voc_algorithm_process(&voc_algorithm_params_, sraw, &voc_index); + + // Store baselines after defined interval or if the difference between current and stored baseline becomes too + // much + if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) { + voc_algorithm_get_states(&voc_algorithm_params_, &this->state0_, &this->state1_); + if (abs(this->baselines_storage_.state0 - this->state0_) > MAXIMUM_STORAGE_DIFF || + abs(this->baselines_storage_.state1 - this->state1_) > MAXIMUM_STORAGE_DIFF) { + this->seconds_since_last_store_ = 0; + this->baselines_storage_.state0 = this->state0_; + this->baselines_storage_.state1 = this->state1_; + + if (this->pref_.save(&this->baselines_storage_)) { + ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04X ,state1: 0x%04X", this->baselines_storage_.state0, + baselines_storage_.state1); + } else { + ESP_LOGW(TAG, "Could not store VOC baselines"); + } + } + } + + return voc_index; +} + +/** + * @brief Return the raw gas measurement + * + * @param temperature The measured temperature in degrees C + * @param humidity The measured relative humidity in % rH + * @return uint16_t The current raw gas measurement + */ +uint16_t SGP40Component::measure_raw_() { + float humidity = NAN; + if (this->humidity_sensor_ != nullptr) { + humidity = this->humidity_sensor_->state; + } + if (isnan(humidity) || humidity < 0.0f || humidity > 100.0f) { + humidity = 50; + } + + float temperature = NAN; + if (this->temperature_sensor_ != nullptr) { + temperature = float(this->temperature_sensor_->state); + } + if (isnan(temperature) || temperature < -40.0f || temperature > 85.0f) { + temperature = 25; + } + + uint8_t command[8]; + + command[0] = 0x26; + command[1] = 0x0F; + + uint16_t rhticks = llround((uint16_t)((humidity * 65535) / 100)); + command[2] = rhticks >> 8; + command[3] = rhticks & 0xFF; + command[4] = generate_crc_(command + 2, 2); + uint16_t tempticks = (uint16_t)(((temperature + 45) * 65535) / 175); + command[5] = tempticks >> 8; + command[6] = tempticks & 0xFF; + command[7] = generate_crc_(command + 5, 2); + + if (!this->write_bytes_raw(command, 8)) { + this->status_set_warning(); + ESP_LOGD(TAG, "write_bytes_raw error"); + return UINT16_MAX; + } + delay(250); // NOLINT + uint16_t raw_data[1]; + + if (!this->read_data_(raw_data, 1)) { + this->status_set_warning(); + ESP_LOGD(TAG, "read_data_ error"); + return UINT16_MAX; + } + return raw_data[0]; +} + +uint8_t SGP40Component::generate_crc_(const uint8_t *data, uint8_t datalen) { + // calculates 8-Bit checksum with given polynomial + uint8_t crc = SGP40_CRC8_INIT; + + for (uint8_t i = 0; i < datalen; i++) { + crc ^= data[i]; + for (uint8_t b = 0; b < 8; b++) { + if (crc & 0x80) + crc = (crc << 1) ^ SGP40_CRC8_POLYNOMIAL; + else + crc <<= 1; + } + } + return crc; +} + +void SGP40Component::update() { + this->seconds_since_last_store_ += this->update_interval_ / 1000; + + uint32_t voc_index = this->measure_voc_index_(); + + if (this->samples_read_++ < this->samples_to_stabalize_) { + ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %u", this->samples_read_, + this->samples_to_stabalize_, voc_index); + return; + } + + if (voc_index != UINT16_MAX) { + this->status_clear_warning(); + this->publish_state(voc_index); + } else { + this->status_set_warning(); + } +} + +void SGP40Component::dump_config() { + ESP_LOGCONFIG(TAG, "SGP40:"); + LOG_I2C_DEVICE(this); + if (this->is_failed()) { + switch (this->error_code_) { + case COMMUNICATION_FAILED: + ESP_LOGW(TAG, "Communication failed! Is the sensor connected?"); + break; + default: + ESP_LOGW(TAG, "Unknown setup error!"); + break; + } + } else { + ESP_LOGCONFIG(TAG, " Serial number: %llu", this->serial_number_); + ESP_LOGCONFIG(TAG, " Minimum Samples: %f", VOC_ALGORITHM_INITIAL_BLACKOUT); + } + LOG_UPDATE_INTERVAL(this); + + if (this->humidity_sensor_ != nullptr && this->temperature_sensor_ != nullptr) { + ESP_LOGCONFIG(TAG, " Compensation:"); + LOG_SENSOR(" ", "Temperature Source:", this->temperature_sensor_); + LOG_SENSOR(" ", "Humidity Source:", this->humidity_sensor_); + } else { + ESP_LOGCONFIG(TAG, " Compensation: No source configured"); + } +} + +bool SGP40Component::write_command_(uint16_t command) { + // Warning ugly, trick the I2Ccomponent base by setting register to the first 8 bit. + return this->write_byte(command >> 8, command & 0xFF); +} + +uint8_t SGP40Component::sht_crc_(uint8_t data1, uint8_t data2) { + uint8_t bit; + uint8_t crc = 0xFF; + + crc ^= data1; + for (bit = 8; bit > 0; --bit) { + if (crc & 0x80) + crc = (crc << 1) ^ 0x131; + else + crc = (crc << 1); + } + + crc ^= data2; + for (bit = 8; bit > 0; --bit) { + if (crc & 0x80) + crc = (crc << 1) ^ 0x131; + else + crc = (crc << 1); + } + + return crc; +} + +bool SGP40Component::read_data_(uint16_t *data, uint8_t len) { + const uint8_t num_bytes = len * 3; + std::vector buf(num_bytes); + + if (!this->parent_->raw_receive(this->address_, buf.data(), num_bytes)) { + return false; + } + + for (uint8_t i = 0; i < len; i++) { + const uint8_t j = 3 * i; + uint8_t crc = sht_crc_(buf[j], buf[j + 1]); + if (crc != buf[j + 2]) { + ESP_LOGE(TAG, "CRC8 Checksum invalid! 0x%02X != 0x%02X", buf[j + 2], crc); + return false; + } + data[i] = (buf[j] << 8) | buf[j + 1]; + } + + return true; +} + +} // namespace sgp40 +} // namespace esphome diff --git a/esphome/components/sgp40/sgp40.h b/esphome/components/sgp40/sgp40.h new file mode 100644 index 0000000000..d448b5e45c --- /dev/null +++ b/esphome/components/sgp40/sgp40.h @@ -0,0 +1,92 @@ +#pragma once + +#include "esphome/core/component.h" +#include "esphome/components/sensor/sensor.h" +#include "esphome/components/i2c/i2c.h" +#include "esphome/core/application.h" +#include "esphome/core/preferences.h" +#include "sensirion_voc_algorithm.h" + +#include + +namespace esphome { +namespace sgp40 { + +struct SGP40Baselines { + int32_t state0; + int32_t state1; +} PACKED; // NOLINT + +// commands and constants +static const uint8_t SGP40_FEATURESET = 0x0020; ///< The required set for this library +static const uint8_t SGP40_CRC8_POLYNOMIAL = 0x31; ///< Seed for SGP40's CRC polynomial +static const uint8_t SGP40_CRC8_INIT = 0xFF; ///< Init value for CRC +static const uint8_t SGP40_WORD_LEN = 2; ///< 2 bytes per word + +// Commands + +static const uint16_t SGP40_CMD_GET_SERIAL_ID = 0x3682; +static const uint16_t SGP40_CMD_GET_FEATURESET = 0x202f; +static const uint16_t SGP40_CMD_SELF_TEST = 0x280e; + +// Shortest time interval of 3H for storing baseline values. +// Prevents wear of the flash because of too many write operations +const long SHORTEST_BASELINE_STORE_INTERVAL = 10800; + +// Store anyway if the baseline difference exceeds the max storage diff value +const long MAXIMUM_STORAGE_DIFF = 50; + +class SGP40Component; + +/// This class implements support for the Sensirion sgp40 i2c GAS (VOC) sensors. +class SGP40Component : public PollingComponent, public sensor::Sensor, public i2c::I2CDevice { + public: + void set_humidity_sensor(sensor::Sensor *humidity) { humidity_sensor_ = humidity; } + void set_temperature_sensor(sensor::Sensor *temperature) { temperature_sensor_ = temperature; } + + void setup() override; + void update() override; + void dump_config() override; + float get_setup_priority() const override { return setup_priority::DATA; } + void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; } + + protected: + /// Input sensor for humidity and temperature compensation. + sensor::Sensor *humidity_sensor_{nullptr}; + sensor::Sensor *temperature_sensor_{nullptr}; + bool write_command_(uint16_t command); + bool read_data_(uint16_t *data, uint8_t len); + int16_t sensirion_init_sensors_(); + int16_t sgp40_probe_(); + uint8_t sht_crc_(uint8_t data1, uint8_t data2); + uint64_t serial_number_; + uint16_t featureset_; + int32_t measure_voc_index_(); + uint8_t generate_crc_(const uint8_t *data, uint8_t datalen); + uint16_t measure_raw_(); + ESPPreferenceObject pref_; + long seconds_since_last_store_; + SGP40Baselines baselines_storage_; + VocAlgorithmParams voc_algorithm_params_; + bool store_baseline_; + int32_t state0_; + int32_t state1_; + uint8_t samples_read_ = 0; + uint8_t samples_to_stabalize_ = static_cast(VOC_ALGORITHM_INITIAL_BLACKOUT) * 2; + + /** + * @brief Request the sensor to perform a self-test, returning the result + * + * @return true: success false:failure + */ + void self_test_(); + enum ErrorCode { + COMMUNICATION_FAILED, + MEASUREMENT_INIT_FAILED, + INVALID_ID, + UNSUPPORTED_ID, + UNKNOWN + } error_code_{UNKNOWN}; +}; +} // namespace sgp40 +} // namespace esphome diff --git a/tests/test1.yaml b/tests/test1.yaml index 41f688e4e8..8742387a7d 100644 --- a/tests/test1.yaml +++ b/tests/test1.yaml @@ -235,10 +235,6 @@ wled: adalight: -mcp3008: - - id: 'mcp3008_hub' - cs_pin: GPIO12 - mcp23s08: - id: 'mcp23s08_hub' cs_pin: GPIO12 @@ -877,12 +873,6 @@ sensor: id: ph_ezo address: 99 unit_of_measurement: 'pH' - - platform: mcp3008 - update_interval: 5s - mcp3008_id: 'mcp3008_hub' - id: freezer_temp_source - reference_voltage: 3.19 - number: 0 esp32_touch: setup_mode: False @@ -1488,14 +1478,14 @@ climate: min_temperature: 18 °C max_temperature: 25 °C temperature_step: 0.1 °C - name: "Electrolux EACS" + name: 'Electrolux EACS' beeper: true outdoor_temperature: - name: "Temp" + name: 'Temp' power_usage: - name: "Power" + name: 'Power' humidity_setpoint: - name: "Hum" + name: 'Hum' midea_dongle: uart_id: uart0 diff --git a/tests/test2.yaml b/tests/test2.yaml index 04514cbef2..fa21c1044a 100644 --- a/tests/test2.yaml +++ b/tests/test2.yaml @@ -54,6 +54,10 @@ deep_sleep: as3935_i2c: irq_pin: GPIO12 +mcp3008: + - id: 'mcp3008_hub' + cs_pin: GPIO12 + sensor: - platform: homeassistant entity_id: sensor.hello_world @@ -212,12 +216,21 @@ sensor: - platform: inkbird_ibsth1_mini mac_address: 38:81:D7:0A:9C:11 temperature: - name: 'Inkbird IBS-TH1 Temperature' + name: 'Inkbird IBS-TH1 Temperature' humidity: - name: 'Inkbird IBS-TH1 Humidity' + name: 'Inkbird IBS-TH1 Humidity' battery_level: - name: 'Inkbird IBS-TH1 Battery Level' - + name: 'Inkbird IBS-TH1 Battery Level' + - platform: sgp40 + name: 'Workshop VOC' + update_interval: 5s + store_baseline: 'true' + - platform: mcp3008 + update_interval: 5s + mcp3008_id: 'mcp3008_hub' + id: freezer_temp_source + reference_voltage: 3.19 + number: 0 time: - platform: homeassistant on_time: