lis2dh12.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Freie Universität Berlin
 *
 * 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

 
#include <stdint.h>
#include <stdbool.h>
 
#include "saul.h"
#include "lis2dh12_registers.h"
 
#include "periph/gpio.h"
#ifdef MODULE_LIS2DH12_SPI
#include "periph/spi.h"
#else
#include "periph/i2c.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(MODULE_LIS2DH12) || defined(DOXYGEN)
#define LIS2DH12_ADDR_DEFAULT       (0x19)
#endif

typedef enum {
    LIS2DH12_SCALE_2G  = 0x0,       
    LIS2DH12_SCALE_4G  = 0x1,       
    LIS2DH12_SCALE_8G  = 0x2,       
    LIS2DH12_SCALE_16G = 0x3,       
} lis2dh12_scale_t;

typedef enum {
    LIS2DH12_RATE_1HZ   = 0x1,      
    LIS2DH12_RATE_10HZ  = 0x2,      
    LIS2DH12_RATE_25HZ  = 0x3,      
    LIS2DH12_RATE_50HZ  = 0x4,      
    LIS2DH12_RATE_100HZ = 0x5,      
    LIS2DH12_RATE_200HZ = 0x6,      
    LIS2DH12_RATE_400HZ = 0x7,      
    LIS2DH12_RATE_1620HZ = 0x8,     
    LIS2DH12_RATE_VERYHIGH = 0x9,   
} lis2dh12_rate_t;

typedef enum {
    LIS2DH12_POWER_DOWN   = 0,  
    LIS2DH12_POWER_LOW    = 1,  
    LIS2DH12_POWER_NORMAL = 2,  
    LIS2DH12_POWER_HIGH   = 3,  
} lis2dh12_resolution_t;
 
#define LIS2DH12_CLICK_X_SINGLE (1 << 0)    
#define LIS2DH12_CLICK_X_DOUBLE (1 << 1)    
#define LIS2DH12_CLICK_Y_SINGLE (1 << 2)    
#define LIS2DH12_CLICK_Y_DOUBLE (1 << 3)    
#define LIS2DH12_CLICK_Z_SINGLE (1 << 4)    
#define LIS2DH12_CLICK_Z_DOUBLE (1 << 5)    

typedef struct {
#if MODULE_LIS2DH12_SPI || DOXYGEN
    spi_t spi;                      
    gpio_t cs;                      
#else
    i2c_t i2c;                      
    uint8_t addr;                   
#endif
#if MODULE_LIS2DH12_INT || DOXYGEN
    gpio_t int1_pin;                
    gpio_t int2_pin;                
#endif
    lis2dh12_scale_t scale;         
    lis2dh12_rate_t rate;           
    lis2dh12_resolution_t resolution; 
} lis2dh12_params_t;

typedef enum {
    LIS2DH12_HP_MODE_NORMAL    = 0x0, 
    LIS2DH12_HP_MODE_REFERENCE = 0x1, 
    LIS2DH12_HP_MODE_AUTORESET = 0x3, 
} lis2dh12_hp_mode_t;

typedef enum {
    LIS2DH12_HP_FREQ_DIV50  = 0, 
    LIS2DH12_HP_FREQ_DIV100 = 1, 
    LIS2DH12_HP_FREQ_DIV200 = 2, 
    LIS2DH12_HP_FREQ_DIV400 = 3, 
} lis2dh12_hp_freq_t;

typedef struct {
    lis2dh12_hp_mode_t Highpass_mode; 
    lis2dh12_hp_freq_t Highpass_freq; 
    bool CLICK_enable;    
    bool INT1_enable;     
    bool INT2_enable;     
    bool DATA_OUT_enable; 
} lis2dh12_highpass_t;

typedef struct {
    bool enable_DOUBLE;     
    bool enable_X_CLICK;    
    bool enable_Y_CLICK;    
    bool enable_Z_CLICK;    
    bool noINT_latency;     
    uint8_t CLICK_thold:7;  
    uint8_t TIME_limit:7;   
    uint8_t TIME_latency;   
    uint8_t TIME_window;    
} lis2dh12_click_t;

typedef struct {
    const lis2dh12_params_t *p;     
} lis2dh12_t;

enum {
    LIS2DH12_OK    =  0,            
    LIS2DH12_NOBUS = -1,            
    LIS2DH12_NODEV = -2,            
    LIS2DH12_NOINT = -3,            
    LIS2DH12_NODATA= -4,            
};
 
/*
 * @brief Interrupt lines
 */
enum {
    LIS2DH12_INT1 = 1,              
    LIS2DH12_INT2 = 2,              
};

typedef struct {
    uint8_t int_config;             
    uint8_t int_threshold:7;        
    uint8_t int_duration:7;         
    uint8_t int_type;               
} lis2dh12_int_params_t;

typedef union {
    struct {
        int16_t x;                      
        int16_t y;                      
        int16_t z;                      
    } axis;                             
    int16_t data[3];                    
} lis2dh12_fifo_data_t;

typedef enum {
    LIS2DH12_FIFO_MODE_BYPASS = 0,      
    LIS2DH12_FIFO_MODE_FIFOMODE,        
    LIS2DH12_FIFO_MODE_STREAM,          
    LIS2DH12_FIFO_MODE_STREAMtoFIFO,    
} lis2dh12_fifo_mode_t;

typedef struct {
    lis2dh12_fifo_mode_t FIFO_mode; 
    uint8_t FIFO_watermark:5;       
    bool FIFO_set_INT2;             
} lis2dh12_fifo_t;

extern const saul_driver_t lis2dh12_saul_driver;
extern const saul_driver_t lis2dh12_saul_temp_driver;
 
#if MODULE_LIS2DH12_INT || DOXYGEN
void lis2dh12_cfg_threshold_event(const lis2dh12_t *dev,
                                  uint32_t mg, uint32_t us,
                                  uint8_t axis, uint8_t event, uint8_t pin);

void lis2dh12_cfg_click_event(const lis2dh12_t *dev, uint32_t mg,
                              uint32_t us_limit, uint32_t us_latency, uint32_t us_window,
                              uint8_t click, uint8_t pin);

void lis2dh12_cfg_disable_event(const lis2dh12_t *dev, uint8_t event, uint8_t pin);

int32_t lis2dh12_wait_event(const lis2dh12_t *dev, uint8_t pin, bool stale_events);
#endif /* MODULE_LIS2DH12_INT */

int lis2dh12_set_fifo(const lis2dh12_t *dev, const lis2dh12_fifo_t *config);

int lis2dh12_restart_fifo(const lis2dh12_t *dev);

uint8_t lis2dh12_read_fifo_data(const lis2dh12_t *dev, lis2dh12_fifo_data_t *fifo_data,
                                uint8_t number);

int lis2dh12_init(lis2dh12_t *dev, const lis2dh12_params_t *params);

int lis2dh12_read(const lis2dh12_t *dev, lis2dh12_fifo_data_t *data);

int lis2dh12_read_temperature(const lis2dh12_t *dev, int16_t *temp);

int lis2dh12_clear_data(const lis2dh12_t *dev);

int lis2dh12_set_scale(lis2dh12_t *dev, lis2dh12_scale_t scale);

lis2dh12_scale_t lis2dh12_get_scale(lis2dh12_t *dev);

int lis2dh12_set_datarate(const lis2dh12_t *dev, lis2dh12_rate_t rate);

uint16_t lis2dh12_get_datarate(const lis2dh12_t *dev);

int lis2dh12_set_resolution(const lis2dh12_t *dev, lis2dh12_resolution_t resolution);

lis2dh12_resolution_t lis2dh12_get_resolution(const lis2dh12_t *dev);

int lis2dh12_set_highpass(const lis2dh12_t *dev, const lis2dh12_highpass_t *config);

int lis2dh12_set_reference(const lis2dh12_t *dev, uint8_t reference);

int lis2dh12_poweron(const lis2dh12_t *dev);

int lis2dh12_poweroff(const lis2dh12_t *dev);
 
#ifdef __cplusplus
}
#endif