driver_sgp41_algorithm.c

Go to the documentation of this file.

 
#include "driver_sgp41_algorithm.h"

#define DEFAULT_SAMPLING_INTERVAL                                    (1.f)                     
#define INITIAL_BLACKOUT                                             (45.f)                    
#define INDEX_GAIN                                                   (230.f)                   
#define SRAW_STD_INITIAL                                             (50.f)                    
#define SRAW_STD_BONUS_VOC                                           (220.f)                   
#define SRAW_STD_NOX                                                 (2000.f)                  
#define TAU_MEAN_HOURS                                               (12.f)                    
#define TAU_VARIANCE_HOURS                                           (12.f)                    
#define TAU_INITIAL_MEAN_VOC                                         (20.f)                    
#define TAU_INITIAL_MEAN_NOX                                         (1200.f)                  
#define INIT_DURATION_MEAN_VOC                                       ((3600.f * 0.75f))        
#define INIT_DURATION_MEAN_NOX                                       ((3600.f * 4.75f))        
#define INIT_TRANSITION_MEAN                                         (0.01f)                   
#define TAU_INITIAL_VARIANCE                                         (2500.f)                  
#define INIT_DURATION_VARIANCE_VOC                                   ((3600.f * 1.45f))        
#define INIT_DURATION_VARIANCE_NOX                                   ((3600.f * 5.70f))        
#define INIT_TRANSITION_VARIANCE                                     (0.01f)                   
#define GATING_THRESHOLD_VOC                                         (340.f)                   
#define GATING_THRESHOLD_NOX                                         (30.f)                    
#define GATING_THRESHOLD_INITIAL                                     (510.f)                   
#define GATING_THRESHOLD_TRANSITION                                  (0.09f)                   
#define GATING_VOC_MAX_DURATION_MINUTES                              ((60.f * 3.f))            
#define GATING_NOX_MAX_DURATION_MINUTES                              ((60.f * 12.f))           
#define GATING_MAX_RATIO                                             (0.3f)                    
#define SIGMOID_L                                                    (500.f)                   
#define SIGMOID_K_VOC                                                (-0.0065f)                
#define SIGMOID_X0_VOC                                               (213.f)                   
#define SIGMOID_K_NOX                                                (-0.0101f)                
#define SIGMOID_X0_NOX                                               (614.f)                   
#define VOC_INDEX_OFFSET_DEFAULT                                     (100.f)                   
#define NOX_INDEX_OFFSET_DEFAULT                                     (1.f)                     
#define LP_TAU_FAST                                                  (20.0f)                   
#define LP_TAU_SLOW                                                  (500.0f)                  
#define LP_ALPHA                                                     (-0.2f)                   
#define VOC_SRAW_MINIMUM                                             (20000)                   
#define NOX_SRAW_MINIMUM                                             (10000)                   
#define PERSISTENCE_UPTIME_GAMMA                                     ((3.f * 3600.f))          
#define TUNING_INDEX_OFFSET_MIN                                      (1)                       
#define TUNING_INDEX_OFFSET_MAX                                      (250)                     
#define TUNING_LEARNING_TIME_OFFSET_HOURS_MIN                        (1)                       
#define TUNING_LEARNING_TIME_OFFSET_HOURS_MAX                        (1000)                    
#define TUNING_LEARNING_TIME_GAIN_HOURS_MIN                          (1)                       
#define TUNING_LEARNING_TIME_GAIN_HOURS_MAX                          (1000)                    
#define TUNING_GATING_MAX_DURATION_MINUTES_MIN                       (0)                       
#define TUNING_GATING_MAX_DURATION_MINUTES_MAX                       (3000)                    
#define TUNING_STD_INITIAL_MIN                                       (10)                      
#define TUNING_STD_INITIAL_MAX                                       (5000)                    
#define TUNING_GAIN_FACTOR_MIN                                       (1)                       
#define TUNING_GAIN_FACTOR_MAX                                       (1000)                    
#define MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING                        (64.f)                    
#define MEAN_VARIANCE_ESTIMATOR_ADDITIONAL_GAMMA_MEAN_SCALING        (8.f)                     
#define MEAN_VARIANCE_ESTIMATOR_FIX16_MAX                            (32767.f)                 

static void a_mean_variance_estimator_set_parameters(sgp41_gas_index_algorithm_t *params)
{
    params->m_mean_variance_estimator_initialized = 0;                                                                                  /* init 0 */
    params->m_mean_variance_estimator_mean = 0.f;                                                                                       /* init mean */
    params->m_mean_variance_estimator_sraw_offset = 0.f;                                                                                /* int offset */
    params->m_mean_variance_estimator_std = params->m_sraw_std_initial;                                                                 /* int std */
    params->m_mean_variance_estimator_gamma_mean = (((MEAN_VARIANCE_ESTIMATOR_ADDITIONAL_GAMMA_MEAN_SCALING *
                                                    MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) *
                                                   (params->m_sampling_interval / 3600.f)) /
                                                   (params->m_tau_mean_hours + (params->m_sampling_interval / 3600.f)));                /* set mean */
    params->m_mean_variance_estimator_gamma_variance = ((MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING *
                                                       (params->m_sampling_interval / 3600.f)) /
                                                       (params->m_tau_variance_hours + (params->m_sampling_interval / 3600.f)));        /* set variance */
    if ((params->m_algorithm_type == SGP41_ALGORITHM_TYPE_NOX))                                                                         /* nox */
    {
        params->m_mean_variance_estimator_gamma_initial_mean = (((MEAN_VARIANCE_ESTIMATOR_ADDITIONAL_GAMMA_MEAN_SCALING *
                                                                MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) *
                                                                params->m_sampling_interval) /
                                                               (TAU_INITIAL_MEAN_NOX +
                                                                params->m_sampling_interval));                                          /* set mean */
    } 
    else
    {
        params->m_mean_variance_estimator_gamma_initial_mean = (((MEAN_VARIANCE_ESTIMATOR_ADDITIONAL_GAMMA_MEAN_SCALING *
                                                                MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING) *
                                                                params->m_sampling_interval) /
                                                               (TAU_INITIAL_MEAN_VOC +
                                                                params->m_sampling_interval));                                          /* set mean */
    }
    params->m_mean_variance_estimator_gamma_initial_variance = ((MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING *
                                                                params->m_sampling_interval) /
                                                               (TAU_INITIAL_VARIANCE + params->m_sampling_interval));                   /* set variance */
    params->m_mean_variance_estimator_n_gamma_mean = 0.f;                                                                               /* init mean */
    params->m_mean_variance_estimator_n_gamma_variance = 0.f;                                                                           /* init variance */
    params->m_mean_variance_estimator_uptime_gamma = 0.f;                                                                               /* init gamma */
    params->m_mean_variance_estimator_uptime_gating = 0.f;                                                                              /* init gating */
    params->m_mean_variance_estimator_gating_duration_minutes = 0.f;                                                                    /* init minutes */
}

static void a_mox_model_set_parameters(sgp41_gas_index_algorithm_t *params, float sraw_std, float sraw_mean)
{
    params->m_mox_model_sraw_std = sraw_std;          /* set std */
    params->m_mox_model_sraw_mean = sraw_mean;        /* set mean */
}

static float a_mean_variance_estimator_get_std(const sgp41_gas_index_algorithm_t *params)
{
    return params->m_mean_variance_estimator_std;        /* return std */
}

static float a_mean_variance_estimator_get_mean(const sgp41_gas_index_algorithm_t *params)
{
    return (params->m_mean_variance_estimator_mean +
            params->m_mean_variance_estimator_sraw_offset);        /* return mean */
}

static void a_sigmoid_scaled_set_parameters(sgp41_gas_index_algorithm_t *params, float x0, float k, float offset_default)
{
    params->m_sigmoid_scaled_k = k;                                  /* set k */
    params->m_sigmoid_scaled_x0 = x0;                                /* set x0 */
    params->m_sigmoid_scaled_offset_default = offset_default;        /* set offset default */
}

static void a_adaptive_lowpass_set_parameters(sgp41_gas_index_algorithm_t *params)
{
    params->m_adaptive_lowpass_a1 = (params->m_sampling_interval /
                                    (LP_TAU_FAST + params->m_sampling_interval));        /* set a1 */
    params->m_adaptive_lowpass_a2 = (params->m_sampling_interval /
                                    (LP_TAU_SLOW + params->m_sampling_interval));        /* set a2 */
    params->m_adaptive_lowpass_initialized = 0;                                          /* init 0 */
}

static void a_init_instances(sgp41_gas_index_algorithm_t *params)
{
    a_mean_variance_estimator_set_parameters(params);                              /* set parameters */
    a_mox_model_set_parameters(params, 
                               a_mean_variance_estimator_get_std(params),
                               a_mean_variance_estimator_get_mean(params));        /* set parameters */
    if ((params->m_algorithm_type == SGP41_ALGORITHM_TYPE_NOX))                    /* nox */
    {
        a_sigmoid_scaled_set_parameters(params, SIGMOID_X0_NOX,
                                        SIGMOID_K_NOX,
                                        NOX_INDEX_OFFSET_DEFAULT);                 /* set parameters */
    }
    else                                                                           /* voc */
    {
        a_sigmoid_scaled_set_parameters(params, SIGMOID_X0_VOC,
                                        SIGMOID_K_VOC,
                                        VOC_INDEX_OFFSET_DEFAULT);                 /* set parameters */
    }
    a_adaptive_lowpass_set_parameters(params);                                     /* set parameters */
}

static void a_mean_variance_estimator_set_states(sgp41_gas_index_algorithm_t *params, float mean, 
                                                 float std, float uptime_gamma)
{
    params->m_mean_variance_estimator_mean = mean;                        /* set mean */
    params->m_mean_variance_estimator_std = std;                          /* set std */
    params->m_mean_variance_estimator_uptime_gamma = uptime_gamma;        /* set uptime gamma */
    params->m_mean_variance_estimator_initialized = 1;                    /* init 1 */
}

static uint8_t a_mean_variance_estimator_is_initialized(sgp41_gas_index_algorithm_t *params)
{
    return params->m_mean_variance_estimator_initialized;        /* return initialized */
}

static void a_mean_variance_estimator_sigmoid_set_parameters(sgp41_gas_index_algorithm_t *params, float x0, float k)
{
    params->m_mean_variance_estimator_sigmoid_k = k;          /* set k */
    params->m_mean_variance_estimator_sigmoid_x0 = x0;        /* set x0 */
}

static float a_mean_variance_estimator_sigmoid_process(sgp41_gas_index_algorithm_t *params, float sample)
{
    float x;
 
    x = (params->m_mean_variance_estimator_sigmoid_k *
        (sample - params->m_mean_variance_estimator_sigmoid_x0));        /* get sigmoid */
    if ((x < -50.f))                                                     /* check x */
    {
        return 1.f;                                                      /* return 1.0 */
    }
    else if ((x > 50.f))                                                 /* check x */
    {
        return 0.f;                                                      /* return 0 */
    }
    else
    {
        return (1.f / (1.f + expf(x)));                                  /* return sigmoid */
    }
}

static void a_mean_variance_estimator_calculate_gamma(sgp41_gas_index_algorithm_t *params)
{
    float uptime_limit;
    float sigmoid_gamma_mean;
    float gamma_mean;
    float gating_threshold_mean;
    float sigmoid_gating_mean;
    float sigmoid_gamma_variance;
    float gamma_variance;
    float gating_threshold_variance;
    float sigmoid_gating_variance;
 
    uptime_limit = (MEAN_VARIANCE_ESTIMATOR_FIX16_MAX - params->m_sampling_interval);                                                 /* set uptime limit */
    if ((params->m_mean_variance_estimator_uptime_gamma < uptime_limit))                                                              /* set uptime limit */
    {
        params->m_mean_variance_estimator_uptime_gamma = (params->m_mean_variance_estimator_uptime_gamma +
                                                          params->m_sampling_interval);                                               /* set gamma */
    }
    if ((params->m_mean_variance_estimator_uptime_gating < uptime_limit))                                                             /* check gating */
    {
        params->m_mean_variance_estimator_uptime_gating = (params->m_mean_variance_estimator_uptime_gating +
                                                           params->m_sampling_interval);                                              /* set gating */
    }
    a_mean_variance_estimator_sigmoid_set_parameters(params, params->m_init_duration_mean,
                                                     INIT_TRANSITION_MEAN);                                                           /* set parameters */
    sigmoid_gamma_mean = a_mean_variance_estimator_sigmoid_process(params, 
                                                                   params->m_mean_variance_estimator_uptime_gamma);                   /* set mean */
    gamma_mean = (params->m_mean_variance_estimator_gamma_mean +
                 ((params->m_mean_variance_estimator_gamma_initial_mean -
                  params->m_mean_variance_estimator_gamma_mean) *
                  sigmoid_gamma_mean));                                                                                               /* set mean */
    gating_threshold_mean = (params->m_gating_threshold + ((GATING_THRESHOLD_INITIAL -
                             params->m_gating_threshold) *
                             a_mean_variance_estimator_sigmoid_process(params, 
                             params->m_mean_variance_estimator_uptime_gating)));                                                      /* set mean */
    a_mean_variance_estimator_sigmoid_set_parameters(params, gating_threshold_mean,
                                                     GATING_THRESHOLD_TRANSITION);                                                    /* set parameters */
    sigmoid_gating_mean = a_mean_variance_estimator_sigmoid_process(params, params->m_gas_index);                                     /* set mean */
    params->m_mean_variance_estimator_n_gamma_mean = (sigmoid_gating_mean * gamma_mean);                                              /* set mean */
    a_mean_variance_estimator_sigmoid_set_parameters(params, params->m_init_duration_variance,
                                                     INIT_TRANSITION_VARIANCE);                                                       /* set parameters */
    sigmoid_gamma_variance = a_mean_variance_estimator_sigmoid_process(params, 
                                                                       params->m_mean_variance_estimator_uptime_gamma);               /* set variance */
    gamma_variance = (params->m_mean_variance_estimator_gamma_variance +
                     ((params->m_mean_variance_estimator_gamma_initial_variance -
                      params->m_mean_variance_estimator_gamma_variance) *
                     (sigmoid_gamma_variance - sigmoid_gamma_mean)));                                                                 /* set variance */
    gating_threshold_variance = (params->m_gating_threshold + ((GATING_THRESHOLD_INITIAL - params->m_gating_threshold) *
                                 a_mean_variance_estimator_sigmoid_process(params, 
                                                                           params->m_mean_variance_estimator_uptime_gating)));        /* set variance */
    a_mean_variance_estimator_sigmoid_set_parameters(params, gating_threshold_variance,
                                                     GATING_THRESHOLD_TRANSITION);                                                    /* set parameters */
    sigmoid_gating_variance = a_mean_variance_estimator_sigmoid_process(params, params->m_gas_index);                                 /* set process */
    params->m_mean_variance_estimator_n_gamma_variance = (sigmoid_gating_variance * gamma_variance);                                  /* set variance */
    params->m_mean_variance_estimator_gating_duration_minutes = (params->m_mean_variance_estimator_gating_duration_minutes +
                                                                ((params->m_sampling_interval / 60.f) * 
                                                                (((1.f - sigmoid_gating_mean) *
                                                                (1.f + GATING_MAX_RATIO)) - GATING_MAX_RATIO)));                      /* set minutes */
    if ((params->m_mean_variance_estimator_gating_duration_minutes < 0.f))                                                            /* check minutes */
    {
        params->m_mean_variance_estimator_gating_duration_minutes = 0.f;                                                              /* init minutes */
    }
    if ((params->m_mean_variance_estimator_gating_duration_minutes > params->m_gating_max_duration_minutes))                          /* check minutes */
    {
        params->m_mean_variance_estimator_uptime_gating = 0.f;                                                                        /* set uptime gating 0 */
    }
}

static void a_mean_variance_estimator_process(sgp41_gas_index_algorithm_t *params, float sraw)
{
    float delta_sgp;
    float c;
    float additional_scaling;
 
    if ((params->m_mean_variance_estimator_initialized == 0))                                                       /* no inited */
    {
        params->m_mean_variance_estimator_initialized = 1;                                                          /* set 1 */
        params->m_mean_variance_estimator_sraw_offset = sraw;                                                       /* set raw */
        params->m_mean_variance_estimator_mean = 0.f;                                                               /* init 0 */
    }
    else                                                                                                            /* inited */
    {
        if (((params->m_mean_variance_estimator_mean >= 100.f) ||
           (params->m_mean_variance_estimator_mean <= -100.f)))                                                     /* check mean */
        {
            params->m_mean_variance_estimator_sraw_offset = (params->m_mean_variance_estimator_sraw_offset + 
                                                             params->m_mean_variance_estimator_mean);               /* set offset */
            params->m_mean_variance_estimator_mean = 0.f;                                                           /* init mean */
        }
        sraw = (sraw - params->m_mean_variance_estimator_sraw_offset);                                              /* set sraw */
        a_mean_variance_estimator_calculate_gamma(params);                                                          /* set gamma */
        delta_sgp = ((sraw - params->m_mean_variance_estimator_mean) /
                     MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING);                                                        /* set sgp */
        if ((delta_sgp < 0.f))                                                                                      /* check sgp */
        {
            c = (params->m_mean_variance_estimator_std - delta_sgp);                                                /* get c */
        }
        else
        {
            c = (params->m_mean_variance_estimator_std + delta_sgp);                                                /* get c */
        }
        additional_scaling = 1.f;                                                                                   /* set scaling */
        if ((c > 1440.f))                                                                                           /* check c */
        {
            additional_scaling = ((c / 1440.f) * (c / 1440.f));                                                     /* set scaling */
        }
        params->m_mean_variance_estimator_std =
            (sqrtf((additional_scaling *
                  (MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING -
                   params->m_mean_variance_estimator_n_gamma_variance))) *
             sqrtf(((params->m_mean_variance_estimator_std *
                  (params->m_mean_variance_estimator_std /
                  (MEAN_VARIANCE_ESTIMATOR_GAMMA_SCALING * additional_scaling))) +
                  (((params->m_mean_variance_estimator_n_gamma_variance *
                  delta_sgp) / additional_scaling) * delta_sgp))));                                                 /* set std */
        params->m_mean_variance_estimator_mean = (params->m_mean_variance_estimator_mean +
                                                 ((params->m_mean_variance_estimator_n_gamma_mean * 
                                                  delta_sgp) /
                                                  MEAN_VARIANCE_ESTIMATOR_ADDITIONAL_GAMMA_MEAN_SCALING));          /* set mean */
    }
}

static float a_mox_model_process(sgp41_gas_index_algorithm_t *params, float sraw)
{
    if ((params->m_algorithm_type == SGP41_ALGORITHM_TYPE_NOX))        /* nox */
    {
        return (((sraw - params->m_mox_model_sraw_mean) /
                SRAW_STD_NOX) *
                params->m_index_gain);                                 /* return raw */
    }
    else                                                               /* voc */
    {
        return (((sraw - params->m_mox_model_sraw_mean) /
               (-1.f * (params->m_mox_model_sraw_std +
                SRAW_STD_BONUS_VOC))) * params->m_index_gain);         /* return raw */
    }
}

static float a_sigmoid_scaled_process(sgp41_gas_index_algorithm_t *params, float sample)
{
    float x;
    float shift;
 
    x = (params->m_sigmoid_scaled_k * (sample - params->m_sigmoid_scaled_x0));        /* get x */
    if ((x < -50.f))                                                                  /* check x */
    {
        return SIGMOID_L;                                                             /* return sigmoid */
    }
    else if ((x > 50.f))                                                              /* check x */
    {
        return 0.f;                                                                   /* return 0 */
    }
    else
    {
        if ((sample >= 0.f))                                                          /* check sample */
        {
            if ((params->m_sigmoid_scaled_offset_default == 1.f))                     /* check default */
            {
                shift = ((500.f / 499.f) * (1.f - params->m_index_offset));           /* set shift */
            }
            else
            {
                shift = ((SIGMOID_L - (5.f * params->m_index_offset)) / 4.f);         /* set shift */
            }
            
            return (((SIGMOID_L + shift) / (1.f + expf(x))) - shift);                 /* return sigmoid */
        }
        else
        {
            return ((params->m_index_offset /
                    params->m_sigmoid_scaled_offset_default) *
                   (SIGMOID_L / (1.f + expf(x))));                                    /* return sigmoid */
        }
    }
}

static float a_adaptive_lowpass_process(sgp41_gas_index_algorithm_t *params, float sample)
{
    float abs_delta;
    float f1;
    float tau_a;
    float a3;
 
    if ((params->m_adaptive_lowpass_initialized == 0))                                       /* init 0 */
    {
        params->m_adaptive_lowpass_x1 = sample;                                              /* set sample */
        params->m_adaptive_lowpass_x2 = sample;                                              /* set sample */
        params->m_adaptive_lowpass_x3 = sample;                                              /* set sample */
        params->m_adaptive_lowpass_initialized = 1;                                          /* set init 1 */
    }
    params->m_adaptive_lowpass_x1 = (((1.f - params->m_adaptive_lowpass_a1) *
                                     params->m_adaptive_lowpass_x1) +
                                    (params->m_adaptive_lowpass_a1 * sample));               /* set adaptive lowpass x1 */
    params->m_adaptive_lowpass_x2 = (((1.f - params->m_adaptive_lowpass_a2) *
                                     params->m_adaptive_lowpass_x2) +
                                    (params->m_adaptive_lowpass_a2 * sample));               /* set adaptive lowpass x2 */
    abs_delta = (params->m_adaptive_lowpass_x1 - params->m_adaptive_lowpass_x2);
    if ((abs_delta < 0.f))                                                                   /* check abs delta */
    {
        abs_delta = (-1.f * abs_delta);                                                      /* get delta */
    }
    f1 = expf((LP_ALPHA * abs_delta));                                                       /* get f1 */
    tau_a = (((LP_TAU_SLOW - LP_TAU_FAST) * f1) + LP_TAU_FAST);                              /* set tau a */
    a3 = (params->m_sampling_interval / (params->m_sampling_interval + tau_a));              /* set a3 */
    params->m_adaptive_lowpass_x3 = (((1.f - a3) * 
                                     params->m_adaptive_lowpass_x3) + (a3 * sample));        /* set adaptive lowpass x3 */
    
    return params->m_adaptive_lowpass_x3;                                                    /* return adaptive lowpass x3 */
}

void sgp41_algorithm_reset(sgp41_gas_index_algorithm_t *params)
{
    params->m_uptime = 0.f;          /* init uptime */
    params->m_sraw = 0.f;            /* init sraw */
    params->m_gas_index = 0;         /* int gas index */
    a_init_instances(params);        /* init instances */
}

void sgp41_algorithm_init_with_sampling_interval(sgp41_gas_index_algorithm_t *params, int32_t algorithm_type, float sampling_interval)
{
    params->m_algorithm_type = algorithm_type;                                          /* set algorithm type */
    params->m_sampling_interval = sampling_interval;                                    /* set sampling interval */
    if ((algorithm_type == SGP41_ALGORITHM_TYPE_NOX))                                   /* nox */
    {
        params->m_index_offset = NOX_INDEX_OFFSET_DEFAULT;                              /* set offset */
        params->m_sraw_minimum = NOX_SRAW_MINIMUM;                                      /* set minimum */
        params->m_gating_max_duration_minutes = GATING_NOX_MAX_DURATION_MINUTES;        /* set minutes */
        params->m_init_duration_mean = INIT_DURATION_MEAN_NOX;                          /* set mean */
        params->m_init_duration_variance = INIT_DURATION_VARIANCE_NOX;                  /* set variance */
        params->m_gating_threshold = GATING_THRESHOLD_NOX;                              /* set threshold */
    }
    else
    {
        params->m_index_offset = VOC_INDEX_OFFSET_DEFAULT;                              /* set offset */
        params->m_sraw_minimum = VOC_SRAW_MINIMUM;                                      /* set minimum */
        params->m_gating_max_duration_minutes = GATING_VOC_MAX_DURATION_MINUTES;        /* set minutes */
        params->m_init_duration_mean = INIT_DURATION_MEAN_VOC;                          /* set mean */
        params->m_init_duration_variance = INIT_DURATION_VARIANCE_VOC;                  /* set variance */
        params->m_gating_threshold = GATING_THRESHOLD_VOC;                              /* set threshold */
    }
    params->m_index_gain = INDEX_GAIN;                                                  /* set gain */
    params->m_tau_mean_hours = TAU_MEAN_HOURS;                                          /* set hours */
    params->m_tau_variance_hours = TAU_VARIANCE_HOURS;                                  /* set hours */
    params->m_sraw_std_initial = SRAW_STD_INITIAL;                                      /* set initial */
    sgp41_algorithm_reset(params);                                                      /* reset */
}

void sgp41_algorithm_init(sgp41_gas_index_algorithm_t *params, int32_t algorithm_type)
{
    sgp41_algorithm_init_with_sampling_interval(params, algorithm_type, DEFAULT_SAMPLING_INTERVAL);        /* init */
}

void sgp41_algorithm_get_sampling_interval(const sgp41_gas_index_algorithm_t *params, float *sampling_interval)
{
    *sampling_interval = params->m_sampling_interval;        /* get sampling interval */
}

void sgp41_algorithm_get_states(const sgp41_gas_index_algorithm_t *params, float* state0, float* state1)
{
    *state0 = a_mean_variance_estimator_get_mean(params);        /* get state0 */
    *state1 = a_mean_variance_estimator_get_std(params);         /* get state1 */
}

void sgp41_algorithm_set_states(sgp41_gas_index_algorithm_t *params, float state0, float state1)
{
    a_mean_variance_estimator_set_states(params, state0, state1, PERSISTENCE_UPTIME_GAMMA);        /* set states */
    a_mox_model_set_parameters(params,
                               a_mean_variance_estimator_get_std(params),
                               a_mean_variance_estimator_get_mean(params));                        /* set parameters */
    params->m_sraw = state0;                                                                       /* set state0 */
}

void sgp41_algorithm_set_tuning_parameters(sgp41_gas_index_algorithm_t *params, int32_t index_offset,
                                           int32_t learning_time_offset_hours, int32_t learning_time_gain_hours,
                                           int32_t gating_max_duration_minutes, int32_t std_initial,
                                           int32_t gain_factor)
{
    params->m_index_offset = ((float)(index_offset));                                      /* set offset */
    params->m_tau_mean_hours = ((float)(learning_time_offset_hours));                      /* set hours */
    params->m_tau_variance_hours = ((float)(learning_time_gain_hours));                    /* set hours */
    params->m_gating_max_duration_minutes = ((float)(gating_max_duration_minutes));        /* set minutes */
    params->m_sraw_std_initial = ((float)(std_initial));                                   /* set initial */
    params->m_index_gain = ((float)(gain_factor));                                         /* set gain */
    a_init_instances(params);                                                              /* init instances */
}

void sgp41_algorithm_get_tuning_parameters(const sgp41_gas_index_algorithm_t *params, int32_t *index_offset,
                                           int32_t *learning_time_offset_hours, int32_t *learning_time_gain_hours,
                                           int32_t *gating_max_duration_minutes, int32_t *std_initial,
                                           int32_t *gain_factor)
{
 
    *index_offset = ((int32_t)(params->m_index_offset));                                      /* get offset */
    *learning_time_offset_hours = ((int32_t)(params->m_tau_mean_hours));                      /* get hours */
    *learning_time_gain_hours = ((int32_t)(params->m_tau_variance_hours));                    /* get hours */
    *gating_max_duration_minutes = ((int32_t)(params->m_gating_max_duration_minutes));        /* get minutes */
    *std_initial = ((int32_t)(params->m_sraw_std_initial));                                   /* get std initial */
    *gain_factor = ((int32_t)(params->m_index_gain));                                         /* get gain factor */
}

void sgp41_algorithm_process(sgp41_gas_index_algorithm_t *params, int32_t sraw, int32_t *gas_index)
{
    if ((params->m_uptime <= INITIAL_BLACKOUT))                                                 /* check time */
    {
        params->m_uptime = (params->m_uptime + params->m_sampling_interval);                    /* set time */
    }
    else
    {
        if (((sraw > 0) && (sraw < 65000)))                                                     /* check sraw */
        {
            if ((sraw < (params->m_sraw_minimum + 1)))                                          /* check sraw */
            {
                sraw = (params->m_sraw_minimum + 1);                                            /* set sraw */
            }
            else if ((sraw > (params->m_sraw_minimum + 32767)))                                 /* check sraw */
            {
                sraw = (params->m_sraw_minimum + 32767);                                        /* set sraw */
            }
            params->m_sraw = ((float)((sraw - params->m_sraw_minimum)));                        /* set sraw */
        }
        if (((params->m_algorithm_type == SGP41_ALGORITHM_TYPE_VOC) 
            || a_mean_variance_estimator_is_initialized(params)))                               /* voc */
        {
            params->m_gas_index = a_mox_model_process(params, params->m_sraw);                  /* set ga index */
            params->m_gas_index = a_sigmoid_scaled_process(params, params->m_gas_index);        /* set ga index */
        }
        else
        {
            params->m_gas_index = params->m_index_offset;                                       /* set gas index */
        }
        params->m_gas_index = a_adaptive_lowpass_process(params, params->m_gas_index);          /* set gas index */
        if ((params->m_gas_index < 0.5f))                                                       /* check gas index */
        {
            params->m_gas_index = 0.5f;                                                         /* set gas index */
        }
        if ((params->m_sraw > 0.f))                                                             /* check sraw */
        {
            a_mean_variance_estimator_process(params, params->m_sraw);                          /* sraw */
            a_mox_model_set_parameters(params,
                                       a_mean_variance_estimator_get_std(params),
                                       a_mean_variance_estimator_get_mean(params));             /* set parameters */
        }
    }
    *gas_index = ((int32_t)((params->m_gas_index + 0.5f)));                                     /* get gas index */
}