ruuvi_task_sensor.c

Go to the documentation of this file.

#include "ruuvi_driver_enabled_modules.h"
#if RT_SENSOR_ENABLED
#include "ruuvi_driver_error.h"
#include "ruuvi_driver_sensor.h"
#include "ruuvi_interface_log.h"
#include "ruuvi_task_flash.h"
#include "ruuvi_task_sensor.h"
 
#include <string.h>
 
#ifndef TASK_SENSOR_LOG_LEVEL
#define TASK_SENSOR_LOG_LEVEL RI_LOG_LEVEL_DEBUG
#endif
 
static inline void LOG (const char * const msg)
{
    ri_log (TASK_SENSOR_LOG_LEVEL, msg);
}
 
static inline void LOGD (const char * const msg)
{
    ri_log (RI_LOG_LEVEL_DEBUG, msg);
}
 
static inline void LOGHEX (const uint8_t * const msg, const size_t len)
{
    ri_log_hex (TASK_SENSOR_LOG_LEVEL, msg, len);
}
 
rd_status_t rt_sensor_initialize (rt_sensor_ctx_t * const sensor)
{
    rd_status_t err_code = RD_SUCCESS;
 
    if ( (NULL == sensor) || (NULL == sensor->init))
    {
        err_code |= RD_ERROR_NULL;
    }
    else if (RD_HANDLE_UNUSED != sensor->handle)
    {
        err_code = sensor->init (& (sensor->sensor), sensor->bus, sensor->handle);
    }
    else
    {
        err_code |= RD_ERROR_NOT_FOUND;
    }
 
    return err_code;
}
 
rd_status_t rt_sensor_store (rt_sensor_ctx_t * const sensor)
{
    rd_status_t err_code = RD_SUCCESS;
 
    if (NULL == sensor)
    {
        err_code |= RD_ERROR_NULL;
    }
    else if (rt_flash_busy())
    {
        err_code |= RD_ERROR_BUSY;
    }
    else
    {
        err_code |= rt_flash_store (sensor->nvm_file, sensor->nvm_record,
                                    & (sensor->configuration),
                                    sizeof (sensor->configuration));
    }
 
    return err_code;
}
 
rd_status_t rt_sensor_load (rt_sensor_ctx_t * const sensor)
{
    rd_status_t err_code = RD_SUCCESS;
 
    if (NULL == sensor)
    {
        err_code |= RD_ERROR_NULL;
    }
    else if (rt_flash_busy())
    {
        err_code |= RD_ERROR_BUSY;
    }
    else
    {
        err_code |= rt_flash_load (sensor->nvm_file, sensor->nvm_record,
                                   & (sensor->configuration),
                                   sizeof (sensor->configuration));
    }
 
    return err_code;
}
 
rd_status_t rt_sensor_configure (rt_sensor_ctx_t * const ctx)
{
    rd_status_t err_code = RD_SUCCESS;
 
    if (NULL == ctx)
    {
        err_code |= RD_ERROR_NULL;
    }
    else if (!rd_sensor_is_init (& (ctx->sensor)))
    {
        err_code |= RD_ERROR_INVALID_STATE;
    }
    else
    {
        LOG ("\r\nAttempting to configure ");
        LOG (ctx->sensor.name);
        LOG (" with:\r\n");
        ri_log_sensor_configuration (TASK_SENSOR_LOG_LEVEL,
                                     & (ctx->configuration), "");
        err_code |= ctx->sensor.configuration_set (& (ctx->sensor),
                    & (ctx->configuration));
        LOG ("Actual configuration:\r\n");
        ri_log_sensor_configuration (TASK_SENSOR_LOG_LEVEL,
                                     & (ctx->configuration), "");
    }
 
    return err_code;
}
 
//ruuvi_endpoint_status_t task_sensor_encode_to_5 (uint8_t * const buffer);
 
rt_sensor_ctx_t * rt_sensor_find_backend (rt_sensor_ctx_t * const sensor_list,
        const size_t count, const char * const name)
{
    rt_sensor_ctx_t * p_sensor = NULL;
 
    for (size_t ii = 0; (count > ii) && (NULL == p_sensor); ii++)
    {
        if (0 == strcmp (sensor_list[ii].sensor.name, name))
        {
            p_sensor = & (sensor_list[ii]);
        }
    }
 
    return p_sensor;
}
 
rt_sensor_ctx_t * rt_sensor_find_provider (rt_sensor_ctx_t * const
        sensor_list, const size_t count, rd_sensor_data_fields_t values)
{
    rt_sensor_ctx_t * p_sensor = NULL;
 
    for (size_t ii = 0; (count > ii) && (NULL == p_sensor); ii++)
    {
        if ( (values.bitfield & sensor_list[ii].sensor.provides.bitfield) == values.bitfield)
        {
            p_sensor = & (sensor_list[ii]);
        }
    }
 
    return p_sensor;
}
#endif