driver_bmp390.h

Go to the documentation of this file.

 
#ifndef DRIVER_BMP390_H
#define DRIVER_BMP390_H
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C"{
#endif



typedef enum
{
    BMP390_INTERFACE_IIC = 0x00,        
    BMP390_INTERFACE_SPI = 0x01,        
} bmp390_interface_t;

typedef enum
{
    BMP390_ADDRESS_ADO_LOW  = (0x76 << 1),        
    BMP390_ADDRESS_ADO_HIGH = (0x77 << 1),        
} bmp390_address_t;

typedef enum
{
    BMP390_BOOL_FALSE = 0x00,        
    BMP390_BOOL_TRUE  = 0x01,        
} bmp390_bool_t;

typedef enum
{
    BMP390_ERROR_FATAL = (1 << 0),        
    BMP390_ERROR_CMD   = (1 << 1),        
    BMP390_ERROR_CONF  = (1 << 2),        
} bmp390_error_t;

typedef enum
{
    BMP390_STATUS_COMMAND_READY = (1 << 4),        
    BMP390_STATUS_PRESS_READY   = (1 << 5),        
    BMP390_STATUS_TEMP_READY    = (1 << 6),        
} bmp390_status_t;

typedef enum
{
    BMP390_EVENT_NONE                  = (0 << 0),        
    BMP390_EVENT_POWER_UP_OR_SOFTRESET = (1 << 0),        
    BMP390_EVENT_ITF_ACT_PT            = (1 << 1),        
    BMP390_EVENT_BOTH                  = (3 << 0),        
} bmp390_event_t;

typedef enum
{
    BMP390_FIFO_DATA_SOURCE_UNFILTERED  = 0,        
    BMP390_FIFO_DATA_SOURCE_FILTERED    = 1,        
} bmp390_fifo_data_source_t;

typedef enum
{
    BMP390_INTERRUPT_STATUS_FIFO_WATERMARK = (1 << 0),        
    BMP390_INTERRUPT_STATUS_FIFO_FULL      = (1 << 1),        
    BMP390_INTERRUPT_STATUS_DATA_READY     = (1 << 3),        
} bmp390_interrupt_status_t;

typedef enum
{
    BMP390_INTERRUPT_ACTIVE_LEVEL_LOWER  = 0x00,        
    BMP390_INTERRUPT_ACTIVE_LEVEL_HIGHER = 0x01,        
} bmp390_interrupt_active_level_t;

typedef enum
{
    BMP390_INTERRUPT_PIN_TYPE_PUSH_PULL  = 0x00,        
    BMP390_INTERRUPT_PIN_TYPE_OPEN_DRAIN = 0x01,        
} bmp390_interrupt_pin_type_t;

typedef enum
{
    BMP390_SPI_WIRE_4 = 0x00,        
    BMP390_SPI_WIRE_3 = 0x01,        
} bmp390_spi_wire_t;

typedef enum
{
    BMP390_IIC_WATCHDOG_PERIOD_1P25_MS = 0x00,        
    BMP390_IIC_WATCHDOG_PERIOD_40_MS   = 0x01,        
} bmp390_iic_watchdog_period_t;

typedef enum
{
    BMP390_MODE_SLEEP_MODE  = 0x00,        
    BMP390_MODE_FORCED_MODE = 0x01,        
    BMP390_MODE_NORMAL_MODE = 0x03,        
} bmp390_mode_t;

typedef enum
{
    BMP390_OVERSAMPLING_x1  = 0x00,        
    BMP390_OVERSAMPLING_x2  = 0x01,        
    BMP390_OVERSAMPLING_x4  = 0x02,        
    BMP390_OVERSAMPLING_x8  = 0x03,        
    BMP390_OVERSAMPLING_x16 = 0x04,        
    BMP390_OVERSAMPLING_x32 = 0x05,        
} bmp390_oversampling_t;

typedef enum
{
    BMP390_ODR_200_HZ    = 0x00,        
    BMP390_ODR_100_HZ    = 0x01,        
    BMP390_ODR_50_HZ     = 0x02,        
    BMP390_ODR_25_HZ     = 0x03,        
    BMP390_ODR_12P5_HZ   = 0x04,        
    BMP390_ODR_6P25_HZ   = 0x05,        
    BMP390_ODR_3P1_HZ    = 0x06,        
    BMP390_ODR_1P5_HZ    = 0x07,        
    BMP390_ODR_0P78_HZ   = 0x08,        
    BMP390_ODR_0P39_HZ   = 0x09,         
    BMP390_ODR_0P2_HZ    = 0x0A,         
    BMP390_ODR_0P1_HZ    = 0x0B,         
    BMP390_ODR_0P05_HZ   = 0x0C,        
    BMP390_ODR_0P02_HZ   = 0x0D,        
    BMP390_ODR_0P01_HZ   = 0x0E,        
    BMP390_ODR_0P006_HZ  = 0x0F,        
    BMP390_ODR_0P003_HZ  = 0x10,        
    BMP390_ODR_0P0015_HZ = 0x11,         
} bmp390_odr_t;

typedef enum
{
    BMP390_FILTER_COEFFICIENT_0   = 0x00,        
    BMP390_FILTER_COEFFICIENT_1   = 0x01,        
    BMP390_FILTER_COEFFICIENT_3   = 0x02,        
    BMP390_FILTER_COEFFICIENT_7   = 0x03,        
    BMP390_FILTER_COEFFICIENT_15  = 0x04,        
    BMP390_FILTER_COEFFICIENT_31  = 0x05,        
    BMP390_FILTER_COEFFICIENT_63  = 0x06,        
    BMP390_FILTER_COEFFICIENT_127 = 0x07,        
} bmp390_filter_coefficient_t;

typedef enum
{
    BMP390_FRAME_TYPE_TEMPERATURE = 0x01,        
    BMP390_FRAME_TYPE_PRESSURE    = 0x02,        
    BMP390_FRAME_TYPE_SENSORTIME  = 0x03,        
} bmp390_frame_type_t;

typedef struct bmp390_frame_s
{
    bmp390_frame_type_t type;        
    uint32_t raw;                    
    float data;                      
} bmp390_frame_t;

typedef struct bmp390_handle_s
{
    uint8_t iic_addr;                                                                   
    uint8_t buf[512 + 1];                                                               
    uint8_t (*iic_init)(void);                                                          
    uint8_t (*iic_deinit)(void);                                                        
    uint8_t (*iic_read)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len);         
    uint8_t (*iic_write)(uint8_t addr, uint8_t reg, uint8_t *buf, uint16_t len);        
    uint8_t (*spi_init)(void);                                                          
    uint8_t (*spi_deinit)(void);                                                        
    uint8_t (*spi_read)(uint8_t reg, uint8_t *buf, uint16_t len);                       
    uint8_t (*spi_write)(uint8_t reg, uint8_t *buf, uint16_t len);                      
    void (*receive_callback)(uint8_t type);                                             
    void (*delay_ms)(uint32_t ms);                                                      
    void (*debug_print)(const char *const fmt, ...);                                    
    uint8_t inited;                                                                     
    uint8_t iic_spi;                                                                    
    uint16_t t1;                                                                        
    uint16_t t2;                                                                        
    int8_t t3;                                                                          
    int16_t p1;                                                                         
    int16_t p2;                                                                         
    int8_t p3;                                                                          
    int8_t p4;                                                                          
    uint16_t p5;                                                                        
    uint16_t p6;                                                                        
    int8_t p7;                                                                          
    int8_t p8;                                                                          
    int16_t p9;                                                                         
    int8_t p10;                                                                         
    int8_t p11;                                                                         
    int64_t t_fine;                                                                     
} bmp390_handle_t;

typedef struct bmp390_info_s
{
    char chip_name[32];                
    char manufacturer_name[32];        
    char interface[8];                 
    float supply_voltage_min_v;        
    float supply_voltage_max_v;        
    float max_current_ma;              
    float temperature_min;             
    float temperature_max;             
    uint32_t driver_version;           
} bmp390_info_t;



#define DRIVER_BMP390_LINK_INIT(HANDLE, STRUCTURE)        memset(HANDLE, 0, sizeof(STRUCTURE))

#define DRIVER_BMP390_LINK_IIC_INIT(HANDLE, FUC)         (HANDLE)->iic_init = FUC

#define DRIVER_BMP390_LINK_IIC_DEINIT(HANDLE, FUC)       (HANDLE)->iic_deinit = FUC

#define DRIVER_BMP390_LINK_IIC_READ(HANDLE, FUC)         (HANDLE)->iic_read = FUC

#define DRIVER_BMP390_LINK_IIC_WRITE(HANDLE, FUC)        (HANDLE)->iic_write = FUC

#define DRIVER_BMP390_LINK_SPI_INIT(HANDLE, FUC)         (HANDLE)->spi_init = FUC

#define DRIVER_BMP390_LINK_SPI_DEINIT(HANDLE, FUC)       (HANDLE)->spi_deinit = FUC

#define DRIVER_BMP390_LINK_SPI_READ(HANDLE, FUC)         (HANDLE)->spi_read = FUC

#define DRIVER_BMP390_LINK_SPI_WRITE(HANDLE, FUC)        (HANDLE)->spi_write = FUC

#define DRIVER_BMP390_LINK_DELAY_MS(HANDLE, FUC)         (HANDLE)->delay_ms = FUC

#define DRIVER_BMP390_LINK_DEBUG_PRINT(HANDLE, FUC)      (HANDLE)->debug_print = FUC

#define DRIVER_BMP390_LINK_RECEIVE_CALLBACK(HANDLE, FUC) (HANDLE)->receive_callback = FUC



uint8_t bmp390_info(bmp390_info_t *info);

uint8_t bmp390_set_addr_pin(bmp390_handle_t *handle, bmp390_address_t addr_pin);

uint8_t bmp390_get_addr_pin(bmp390_handle_t *handle, bmp390_address_t *addr_pin);

uint8_t bmp390_set_interface(bmp390_handle_t *handle, bmp390_interface_t interface);

uint8_t bmp390_get_interface(bmp390_handle_t *handle, bmp390_interface_t *interface);

uint8_t bmp390_irq_handler(bmp390_handle_t *handle);

uint8_t bmp390_init(bmp390_handle_t *handle);

uint8_t bmp390_deinit(bmp390_handle_t *handle);

uint8_t bmp390_read_temperature_pressure(bmp390_handle_t *handle, uint32_t *temperature_raw, float *temperature_c, 
                                         uint32_t *pressure_raw, float *pressure_pa);

uint8_t bmp390_read_temperature(bmp390_handle_t *handle, uint32_t *raw, float *c);

uint8_t bmp390_read_pressure(bmp390_handle_t *handle, uint32_t *raw, float *pa);

uint8_t bmp390_get_revision_id(bmp390_handle_t *handle, uint8_t *id);

uint8_t bmp390_get_error(bmp390_handle_t *handle, uint8_t *err);

uint8_t bmp390_get_status(bmp390_handle_t *handle, uint8_t *status);

uint8_t bmp390_get_sensortime(bmp390_handle_t *handle, uint32_t *t);

uint8_t bmp390_get_event(bmp390_handle_t *handle, bmp390_event_t *event);

uint8_t bmp390_set_spi_wire(bmp390_handle_t *handle, bmp390_spi_wire_t wire);

uint8_t bmp390_get_spi_wire(bmp390_handle_t *handle, bmp390_spi_wire_t *wire);

uint8_t bmp390_set_iic_watchdog_timer(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_iic_watchdog_timer(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_iic_watchdog_period(bmp390_handle_t *handle, bmp390_iic_watchdog_period_t period);

uint8_t bmp390_get_iic_watchdog_period(bmp390_handle_t *handle, bmp390_iic_watchdog_period_t *period);

uint8_t bmp390_set_pressure(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_pressure(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_temperature(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_temperature(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_mode(bmp390_handle_t *handle, bmp390_mode_t mode);

uint8_t bmp390_get_mode(bmp390_handle_t *handle, bmp390_mode_t *mode);

uint8_t bmp390_set_pressure_oversampling(bmp390_handle_t *handle, bmp390_oversampling_t oversampling);

uint8_t bmp390_get_pressure_oversampling(bmp390_handle_t *handle, bmp390_oversampling_t *oversampling);

uint8_t bmp390_set_temperature_oversampling(bmp390_handle_t *handle, bmp390_oversampling_t oversampling);

uint8_t bmp390_get_temperature_oversampling(bmp390_handle_t *handle, bmp390_oversampling_t *oversampling);

uint8_t bmp390_set_odr(bmp390_handle_t *handle, bmp390_odr_t odr);

uint8_t bmp390_get_odr(bmp390_handle_t *handle, bmp390_odr_t *odr);

uint8_t bmp390_set_filter_coefficient(bmp390_handle_t *handle, bmp390_filter_coefficient_t coefficient);

uint8_t bmp390_get_filter_coefficient(bmp390_handle_t *handle, bmp390_filter_coefficient_t *coefficient);

uint8_t bmp390_softreset(bmp390_handle_t *handle);



uint8_t bmp390_get_interrupt_status(bmp390_handle_t *handle, uint8_t *status);

uint8_t bmp390_set_interrupt_pin_type(bmp390_handle_t *handle, bmp390_interrupt_pin_type_t pin_type);

uint8_t bmp390_get_interrupt_pin_type(bmp390_handle_t *handle, bmp390_interrupt_pin_type_t *pin_type);

uint8_t bmp390_set_interrupt_active_level(bmp390_handle_t *handle, bmp390_interrupt_active_level_t level);

uint8_t bmp390_get_interrupt_active_level(bmp390_handle_t *handle, bmp390_interrupt_active_level_t *level);

uint8_t bmp390_set_latch_interrupt_pin_and_interrupt_status(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_latch_interrupt_pin_and_interrupt_status(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_interrupt_fifo_watermark(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_interrupt_fifo_watermark(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_interrupt_fifo_full(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_interrupt_fifo_full(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_interrupt_data_ready(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_interrupt_data_ready(bmp390_handle_t *handle, bmp390_bool_t *enable);



uint8_t bmp390_get_fifo_length(bmp390_handle_t *handle, uint16_t *length);

uint8_t bmp390_get_fifo_data(bmp390_handle_t *handle, uint8_t *data, uint16_t length);

uint8_t bmp390_set_fifo_watermark(bmp390_handle_t *handle, uint16_t watermark);

uint8_t bmp390_get_fifo_watermark(bmp390_handle_t *handle, uint16_t *watermark);

uint8_t bmp390_set_fifo(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_fifo(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_fifo_stop_on_full(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_fifo_stop_on_full(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_fifo_sensortime_on(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_fifo_sensortime_on(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_fifo_pressure_on(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_fifo_pressure_on(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_fifo_temperature_on(bmp390_handle_t *handle, bmp390_bool_t enable);

uint8_t bmp390_get_fifo_temperature_on(bmp390_handle_t *handle, bmp390_bool_t *enable);

uint8_t bmp390_set_fifo_subsampling(bmp390_handle_t *handle, uint8_t subsample);

uint8_t bmp390_get_fifo_subsampling(bmp390_handle_t *handle, uint8_t *subsample);

uint8_t bmp390_set_fifo_data_source(bmp390_handle_t *handle, bmp390_fifo_data_source_t source);

uint8_t bmp390_get_fifo_data_source(bmp390_handle_t *handle, bmp390_fifo_data_source_t *source);

uint8_t bmp390_flush_fifo(bmp390_handle_t *handle);

uint8_t bmp390_read_fifo(bmp390_handle_t *handle, uint8_t *buf, uint16_t *len);

uint8_t bmp390_fifo_parse(bmp390_handle_t *handle, uint8_t *buf, uint16_t buf_len, bmp390_frame_t *frame, uint16_t *frame_len);



uint8_t bmp390_set_reg(bmp390_handle_t *handle, uint8_t reg, uint8_t value);

uint8_t bmp390_get_reg(bmp390_handle_t *handle, uint8_t reg, uint8_t *value);


 
#ifdef __cplusplus
}
#endif
 
#endif