twr_lp8.h

#ifndef _TWR_LP8_H
#define _TWR_LP8_H
 
#include <twr_scheduler.h>
#include <twr_tick.h>
 
 
 
typedef enum
{
    TWR_LP8_EVENT_ERROR = 0,
 
    TWR_LP8_EVENT_UPDATE = 1
 
} twr_lp8_event_t;
 
 
typedef enum
{
    TWR_LP8_CALIBRATION_BACKGROUND_UNFILTERED = 0x50,
 
    TWR_LP8_CALIBRATION_BACKGROUND_FILTERED = 0x51,
 
    TWR_LP8_CALIBRATION_BACKGROUND_UNFILTERED_RF = 0x52,
 
    TWR_LP8_CALIBRATION_BACKGROUND_FILTERED_RF = 0x53,
 
    TWR_LP8_CALIBRATION_ABC = 0x70,
 
    TWR_LP8_CALIBRATION_ATWR_RF = 0x72
 
} twr_lp8_calibration_t;
 
 
typedef struct twr_lp8_t twr_lp8_t;
 
 
typedef struct
{
    bool (*init)(void);
 
    bool (*charge_enable)(bool state);
 
    bool (*device_enable)(bool state);
 
    bool (*read_signal_rdy)(int *value);
 
    bool (*uart_enable)(bool state);
 
    size_t (*uart_write)(uint8_t *buffer, size_t length);
 
    size_t (*uart_read)(uint8_t *buffer, size_t length);
 
} twr_lp8_driver_t;
 
 
typedef enum
{
    TWR_LP8_STATE_ERROR = -1,
    TWR_LP8_STATE_INITIALIZE = 0,
    TWR_LP8_STATE_READY = 1,
    TWR_LP8_STATE_PRECHARGE = 2,
    TWR_LP8_STATE_CHARGE = 3,
    TWR_LP8_STATE_BOOT = 4,
    TWR_LP8_STATE_BOOT_READ = 5,
    TWR_LP8_STATE_MEASURE = 6,
    TWR_LP8_STATE_MEASURE_READ = 7
 
} twr_lp8_state_t;
 
typedef enum
{
    TWR_LP8_ERROR_INITIALIZE = 0,
    TWR_LP8_ERROR_PRECHARGE = 1,
 
    TWR_LP8_ERROR_CHARGE_CHARGE_ENABLE = 2,
    TWR_LP8_ERROR_CHARGE_DEVICE_ENABLE = 3,
 
    TWR_LP8_ERROR_BOOT_SIGNAL_READY = 4,
    TWR_LP8_ERROR_BOOT_TIMEOUT = 5,
    TWR_LP8_ERROR_BOOT_UART_ENABLE = 6,
    TWR_LP8_ERROR_BOOT_UART_WRITE = 7,
 
    TWR_LP8_ERROR_BOOT_READ_UART_ENABLE = 8,
    TWR_LP8_ERROR_BOOT_READ_DEVICE_ADDRESS = 9,
    TWR_LP8_ERROR_BOOT_READ_COMMAND = 10,
    TWR_LP8_ERROR_BOOT_READ_CRC = 11,
    TWR_LP8_ERROR_BOOT_READ_TIMEOUT = 12,
 
    TWR_LP8_ERROR_MEASURE_SIGNAL_RDY = 13,
    TWR_LP8_ERROR_MEASURE_SIGNAL_RDY_TIMEOUT = 14,
    TWR_LP8_ERROR_MEASURE_UART_ENABLE = 15,
    TWR_LP8_ERROR_MEASURE_UART_WRITE = 16,
 
    TWR_LP8_ERROR_MEASURE_READ_UART_ENABLE = 17,
    TWR_LP8_ERROR_MEASURE_READ_DEVICE_ENABLE = 18,
    TWR_LP8_ERROR_MEASURE_READ_DEVICE_ADDRESS = 19,
    TWR_LP8_ERROR_MEASURE_READ_COMMAND = 20,
    TWR_LP8_ERROR_MEASURE_READ_CRC = 21,
    TWR_LP8_ERROR_MEASURE_READ_CALIBRATION_RUN = 22,
    TWR_LP8_ERROR_MEASURE_READ_STATUS1 = 23,
    TWR_LP8_ERROR_MEASURE_READ_TIMEOUT = 24
 
} twr_lp8_error_t;
 
struct twr_lp8_t
{
    const twr_lp8_driver_t *_driver;
    twr_scheduler_task_id_t _task_id_interval;
    twr_scheduler_task_id_t _task_id_measure;
    void (*_event_handler)(twr_lp8_event_t, void *);
    void *_event_param;
    twr_tick_t _update_interval;
    twr_lp8_state_t _state;
    bool _first_measurement_done;
    twr_tick_t _tick_timeout;
    twr_tick_t _tick_calibration;
    twr_lp8_calibration_t _calibration;
    bool _calibration_run;
    uint8_t _rx_buffer[49];
    size_t _rx_buffer_length;
    uint8_t _tx_buffer[33];
    uint8_t _sensor_state[23];
    bool _valid;
    int16_t _concentration;
    uint16_t _pressure;
    twr_lp8_error_t _error;
 
};
 
 
 
void twr_lp8_init(twr_lp8_t *self, const twr_lp8_driver_t *driver);
 
 
void twr_lp8_set_event_handler(twr_lp8_t *self, void (*event_handler)(twr_lp8_event_t, void *), void *event_param);
 
 
void twr_lp8_set_update_interval(twr_lp8_t *self, twr_tick_t interval);
 
 
bool twr_lp8_measure(twr_lp8_t *self);
 
 
bool twr_lp8_get_concentration_ppm(twr_lp8_t *self, float *ppm);
 
 
bool twr_lp8_get_error(twr_lp8_t *self, twr_lp8_error_t *error);
 
 
void twr_lp8_calibration(twr_lp8_t *self, twr_lp8_calibration_t calibration);
 
 
#endif // _TWR_LP8_H