l3gxxxx.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Gunar Schorcht
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#include <stdbool.h>
#include <stdint.h>
 
#include "mutex.h"
#include "periph/gpio.h"
#include "periph/i2c.h"
#include "periph/spi.h"
 
#include "l3gxxxx_regs.h"
 
#if !IS_USED(MODULE_L3GD20H) && !IS_USED(MODULE_L3GD20) \
                             && !IS_USED(MODULE_L3G4200D_NG) \
                             && !IS_USED(MODULE_A3G4250D) \
                             && !IS_USED(MODULE_I3G4250D)
#error Please select your sensor variant by using the respective pseudomodule.
#endif
 
#if IS_USED(MODULE_L3GD20H) || IS_USED(MODULE_L3GD20)
#define L3GXXXX_I2C_ADDR_1      (0x6a)  
#define L3GXXXX_I2C_ADDR_2      (0x6b)  
#else
#define L3GXXXX_I2C_ADDR_1      (0x68)  
#define L3GXXXX_I2C_ADDR_2      (0x69)  
#endif
#define L3GXXXX_CHIP_ID_L3GD20H  (0xd7)  
#define L3GXXXX_CHIP_ID_L3GD20   (0xd4)  
#define L3GXXXX_CHIP_ID_X3G42XXD (0xd3)  
typedef enum {
    L3GXXXX_OK,                   
    L3GXXXX_ERROR_I2C,            
    L3GXXXX_ERROR_SPI,            
    L3GXXXX_ERROR_WRONG_CHIP_ID,  
    L3GXXXX_ERROR_INV_DEV,        
    L3GXXXX_ERROR_INV_MODE,       
    L3GXXXX_ERROR_INV_FIFO_MODE,  
    L3GXXXX_ERROR_INV_INT_TYPE,   
    L3GXXXX_ERROR_NO_NEW_DATA,    
    L3GXXXX_ERROR_RAW_DATA,       
    L3GXXXX_ERROR_RAW_DATA_FIFO,  
    L3GXXXX_ERROR_NO_INT1_PIN,    
    L3GXXXX_ERROR_NO_INT2_PIN,    
    L3GXXXX_ERROR_BYPASS_MODE,    
    L3GXXXX_ERROR_FIFO_MODE,      
} l3gxxxx_error_codes_t;
 
typedef enum {
    L3GXXXX_ODR_100_12  = 0x00, 
    L3GXXXX_ODR_100_25  = 0x01, 
    L3GXXXX_ODR_200_12  = 0x04, 
    L3GXXXX_ODR_200_25  = 0x05, 
    L3GXXXX_ODR_200_50  = 0x06, 
    L3GXXXX_ODR_200_70  = 0x07, 
    L3GXXXX_ODR_400_20  = 0x08, 
    L3GXXXX_ODR_400_25  = 0x09, 
    L3GXXXX_ODR_400_50  = 0x0a, 
    L3GXXXX_ODR_400_110 = 0x0b, 
    L3GXXXX_ODR_800_30  = 0x0c, 
    L3GXXXX_ODR_800_35  = 0x0d, 
    L3GXXXX_ODR_800_50  = 0x0e, 
    L3GXXXX_ODR_800_100 = 0x0f, 
#if IS_USED(MODULE_L3GD20H) || IS_USED(MODULE_L3GXXXX_LOW_ODR) || DOXYGEN
    L3GXXXX_ODR_12      = 0x10, 
    L3GXXXX_ODR_25      = 0x14, 
    L3GXXXX_ODR_50      = 0x18, 
#endif
} l3gxxxx_odr_t;
 
typedef enum {
    L3GXXXX_SCALE_245_DPS  = 0,  
    L3GXXXX_SCALE_500_DPS  = 1,  
    L3GXXXX_SCALE_2000_DPS = 2,  
} l3gxxxx_scale_t;
 
typedef enum {
    L3GXXXX_BYPASS           = 0, 
    L3GXXXX_FIFO             = 1, 
    L3GXXXX_STREAM           = 2, 
#if IS_USED(MODULE_L3GD20H) || IS_USED(MODULE_L3GD20) || DOXYGEN
    L3GXXXX_STREAM_TO_FIFO   = 3, 
    L3GXXXX_BYPASS_TO_STREAM = 4, 
#endif
#if IS_USED(MODULE_L3GD20H) || DOXYGEN
    L3GXXXX_DYNAMIC_STREAM   = 6, 
    L3GXXXX_BYPASS_TO_FIFO   = 7  
#endif
} l3gxxxx_fifo_mode_t;
 
typedef enum {
    L3GXXXX_NO_FILTER    = 0,   
    L3GXXXX_HPF_ONLY     = 1,   
    L3GXXXX_LPF2_ONLY    = 2,   
    L3GXXXX_HPF_AND_LPF2 = 3    
} l3gxxxx_filter_sel_t;
 
typedef enum {
    L3GXXXX_HPF_NORMAL    = 0,  
    L3GXXXX_HPF_REFERENCE = 1,  
    L3GXXXX_HPF_AUTORESET = 3   
} l3gxxxx_hpf_mode_t;
 
typedef enum {
    L3GXXXX_INT_DATA_READY = L3GXXXX_INT2_DRDY,
    L3GXXXX_INT_FIFO_WATERMARK = L3GXXXX_INT2_WTM,
    L3GXXXX_INT_FIFO_OVERRUN = L3GXXXX_INT2_ORUN,
    L3GXXXX_INT_FIFO_EMPTY = L3GXXXX_INT2_EMPTY,
    L3GXXXX_INT_EVENT = L3GXXXX_INT1_IG,
} l3gxxxx_int_types_t;
 
#define L3GXXXX_INT_DATA (L3GXXXX_INT_DATA_READY | \
                          L3GXXXX_INT_FIFO_WATERMARK | \
                          L3GXXXX_INT_FIFO_OVERRUN | \
                          L3GXXXX_INT_FIFO_EMPTY)
 
typedef struct {
    uint16_t x_threshold;    
    uint16_t y_threshold;    
    uint16_t z_threshold;    
    bool x_low_enabled;      
    bool x_high_enabled;     
    bool y_low_enabled;      
    bool y_high_enabled;     
    bool z_low_enabled;      
    bool z_high_enabled;     
    l3gxxxx_filter_sel_t filter; 
    bool and_or;       
    bool latch;        
    uint8_t duration;  
    bool wait;         
    bool counter_mode; 
} l3gxxxx_int_event_cfg_t;
 
typedef union {
    struct {
        uint8_t x_low :1; 
        uint8_t x_high:1; 
        uint8_t y_low :1; 
        uint8_t y_high:1; 
        uint8_t z_low :1; 
        uint8_t z_high:1; 
        uint8_t active:1; 
        uint8_t unused:1; 
    };
    uint8_t val;          
} l3gxxxx_int_event_src_t;
 
typedef union {
    struct {
        uint8_t fifo_empty    :1;  
        uint8_t fifo_overrun  :1;  
        uint8_t fifo_watermark:1;  
        uint8_t data_ready    :1;  
        uint8_t unused        :4;  
    };
    uint8_t val;                   
} l3gxxxx_int_data_src_t;
 
typedef struct {
    l3gxxxx_int_event_src_t event;  
    l3gxxxx_int_data_src_t  data;   
} l3gxxxx_int_src_t;
 
typedef enum {
    L3GXXXX_HIGH = 0,       
    L3GXXXX_LOW             
} l3gxxxx_int_pin_level_t;
 
typedef enum {
    L3GXXXX_PUSH_PULL = 0,  
    L3GXXXX_OPEN_DRAIN      
} l3gxxxx_int_pin_type_t;
 
typedef struct {
    int16_t x; 
    int16_t y; 
    int16_t z; 
} l3gxxxx_raw_data_t;
 
typedef struct {
    int32_t x; 
    int32_t y; 
    int32_t z; 
} l3gxxxx_data_t;
 
typedef l3gxxxx_raw_data_t l3gxxxx_raw_data_fifo_t[32];
 
typedef l3gxxxx_data_t l3gxxxx_data_fifo_t[32];
 
typedef enum {
#if IS_USED(MODULE_L3GXXXX_I2C) || DOXYGEN
    L3GXXXX_I2C,                   
#endif
#if IS_USED(MODULE_L3GXXXX_SPI) || DOXYGEN
    L3GXXXX_SPI,                   
#endif
} l3gxxxx_if_t;
 
#if IS_USED(MODULE_L3GXXXX_I2C) || DOXYGEN
typedef struct {
    i2c_t   dev;                    
    uint8_t addr;                   
} l3gxxxx_i2c_params_t;
#endif
 
#if IS_USED(MODULE_L3GXXXX_SPI) || DOXYGEN
typedef struct {
    spi_t     dev;                  
    spi_clk_t clk;                  
    gpio_t    cs;                   
} l3gxxxx_spi_params_t;
#endif
 
typedef struct {
    l3gxxxx_if_t type;             
    union {
#if IS_USED(MODULE_L3GXXXX_I2C) || DOXYGEN
        l3gxxxx_i2c_params_t i2c;  
#endif
#if IS_USED(MODULE_L3GXXXX_SPI) || DOXYGEN
        l3gxxxx_spi_params_t spi;  
#endif
    };
} l3gxxxx_if_params_t;
 
typedef struct {
    l3gxxxx_if_params_t  if_params;      
    l3gxxxx_odr_t        odr;            
    l3gxxxx_scale_t      scale;          
    l3gxxxx_filter_sel_t filter_sel;     
    l3gxxxx_hpf_mode_t   hpf_mode;       
    uint8_t              hpf_cutoff;     
#if IS_USED(MODULE_L3GXXXX_FIFO) || DOXYGEN
    l3gxxxx_fifo_mode_t  fifo_mode;      
    uint8_t              fifo_watermark; 
#endif
 
#if IS_USED(MODULE_L3GXXXX_IRQ_DATA) || DOXYGEN
    gpio_t               int2_pin;       
#endif
 
#if IS_USED(MODULE_L3GXXXX_IRQ_EVENT) || DOXYGEN
    l3gxxxx_int_event_cfg_t int1_cfg;    
    gpio_t                  int1_pin;    
#endif
 
} l3gxxxx_params_t;
 
typedef struct {
    l3gxxxx_params_t params;      
    l3gxxxx_int_types_t int_type; 
    mutex_t int_lock;             
    enum {                        
        L3GD20H,                  
        L3GD20,                   
        X3G42XXD                  
    } sensor;                     
} l3gxxxx_t;
 
int l3gxxxx_init(l3gxxxx_t *dev, const l3gxxxx_params_t *params);
 
#if IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN
int l3gxxxx_set_mode(l3gxxxx_t *dev,
                     l3gxxxx_odr_t odr, bool x, bool y, bool z);
 
int l3gxxxx_set_scale(l3gxxxx_t *dev, l3gxxxx_scale_t scale);
 
#endif /* IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN */
int l3gxxxx_power_down (l3gxxxx_t *dev);
 
int l3gxxxx_power_up (l3gxxxx_t *dev);
 
#if IS_USED(MODULE_L3GXXXX_SLEEP) || DOXYGEN
int l3gxxxx_sleep (l3gxxxx_t *dev);
 
int l3gxxxx_wake_up (l3gxxxx_t *dev);
 
#endif /* IS_USED(MODULE_L3GXXXX_SLEEP) || DOXYGEN */
int l3gxxxx_data_ready(const l3gxxxx_t *dev);
 
int l3gxxxx_read(const l3gxxxx_t *dev, l3gxxxx_data_t *data);
 
int l3gxxxx_read_raw(const l3gxxxx_t *dev, l3gxxxx_raw_data_t *raw);
 
#if IS_USED(MODULE_L3GXXXX_FIFO) || DOXYGEN
 
#if IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN
int l3gxxxx_set_fifo_mode(l3gxxxx_t *dev,
                          l3gxxxx_fifo_mode_t mode, uint8_t watermark);
 
#endif /* IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN */
 
int l3gxxxx_read_fifo(const l3gxxxx_t *dev,
                      l3gxxxx_data_fifo_t data);
 
int l3gxxxx_read_raw_fifo(const l3gxxxx_t *dev,
                          l3gxxxx_raw_data_fifo_t raw);
 
#endif /* IS_USED(MODULE_L3GXXXX_FIFO) || DOXYGEN */
#if IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN
int l3gxxxx_select_output_filter(l3gxxxx_t *dev,
                                 l3gxxxx_filter_sel_t filter);
 
int l3gxxxx_config_hpf(const l3gxxxx_t *dev,
                       l3gxxxx_hpf_mode_t mode, uint8_t cutoff);
 
int l3gxxxx_set_hpf_ref(const l3gxxxx_t *dev, int8_t ref);
 
int l3gxxxx_get_hpf_ref(const l3gxxxx_t *dev, int8_t *ref);
 
#endif /* IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN */
#if IS_USED(MODULE_L3GXXXX_IRQ) || DOXYGEN
int l3gxxxx_enable_int(const l3gxxxx_t *dev,
                       l3gxxxx_int_types_t mask, bool enable);
 
l3gxxxx_int_src_t l3gxxxx_wait_int(l3gxxxx_t *dev);
 
#if IS_USED(MODULE_L3GXXXX_IRQ_EVENT) || DOXYGEN
int l3gxxxx_set_int_event_cfg(const l3gxxxx_t *dev,
                              const l3gxxxx_int_event_cfg_t *cfg);
 
#if IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN
int l3gxxxx_get_int_event_cfg(const l3gxxxx_t *dev,
                              l3gxxxx_int_event_cfg_t *cfg);
 
#endif /* IS_USED(MODULE_L3GXXXX_CONFIG) || DOXYGEN */
#endif /* IS_USED(MODULE_L3GXXXX_IRQ_EVENT) || DOXYGEN */
 
#endif /* IS_USED(MODULE_L3GXXXX_IRQ) || DOXYGEN */
 
int l3gxxxx_reg_write(const l3gxxxx_t *dev,
                      uint8_t reg, const uint8_t *data, uint8_t len);
 
int l3gxxxx_reg_read(const l3gxxxx_t *dev,
                     uint8_t reg, uint8_t *data, uint8_t len);
#ifdef __cplusplus
}
#endif