ADXL345.hh

Go to the documentation of this file.

#ifndef COSA_ADXL345_HH
#define COSA_ADXL345_HH

#include "Cosa/TWI.hh"
#include "Cosa/IOStream.hh"

class ADXL345 : private TWI::Driver {
public:

  ADXL345(bool use_alt_address = false) :
    TWI::Driver(use_alt_address ? 0x53 : 0x1d)
  {}

  bool begin();

  bool end();

  struct offset_t {
    int8_t x;
    int8_t y;
    int8_t z;
  };

  void calibrate(int8_t x, int8_t y, int8_t z)
    __attribute__((always_inline))
  {
    offset_t ofs;
    ofs.x = x;
    ofs.y = y;
    ofs.z = z;
    write(OFS, &ofs, sizeof(ofs));
  }

  void calibrate();

  struct sample_t {
    int x;
    int y;
    int z;
  };

  void sample(sample_t& s)
    __attribute__((always_inline))
  {
    read(DATA, &s, sizeof(s));
  }

  enum {
    DATA_READY = 7,             
    SINGLE_TAP = 6,             
    DOUBLE_TAP = 5,             
    ACT = 4,                    
    INACT = 3,                  
    FREE_FALL = 2,              
    WATERMARK = 1,              
    OVERRUN = 0                 
  } __attribute__((packed));

  uint8_t is_activity();

protected:
  enum Register {
    DEVID = 0x00,               
    THRESH_TAP = 0x1D,          
    OFS = 0x1E,                 
    DUR = 0x21,                 
    LATENT = 0x22,              
    WINDOW = 0x23,              
    THRESH_ACT = 0x24,          
    THRESH_INACT = 0x25,        
    TIME_INACT = 0x26,          
    ACT_INACT_CTL = 0x27,       
    THRESH_FF = 0x28,           
    TIME_FF = 0x29,             
    TAP_AXES = 0x2A,            
    ACT_TAP_STATUS = 0x2B,      
    BW_RATE = 0x2C,             
    POWER_CTL = 0x2D,           
    INT_ENABLE = 0x2E,          
    INT_MAP = 0x2F,             
    INT_SOURCE = 0x30,          
    DATA_FORMAT = 0x31,         
    DATA = 0x32,                
    FIFO_CTL = 0x38,            
    FIFO_STATUS = 0x39          
  } __attribute__((packed));

  static const uint8_t ID = 0xe5;

  enum {
    ACT_AC_DC = 7,              
    ACT_X_EN = 6,               
    ACT_Y_EN = 5,               
    ACT_Z_EN = 4,               
    INACT_AC_DC = 3,            
    INACT_X_EN = 2,             
    INACT_Y_EN = 1,             
    INACT_Z_EN = 0              
  } __attribute__((packed));

  enum {
    SUPPRES = 3,                
    TAP_X_EN = 2,               
    TAP_Y_EN = 1,               
    TAP_Z_EN = 0,               
  } __attribute__((packed));

  enum {
    ACT_X_SRC = 6,              
    ACT_Y_SRC = 5,              
    ACT_Z_SRC = 4,              
    ASLEEP = 3,                 
    TAP_X_SRC = 2,              
    TAP_Y_SRC = 1,              
    TAP_Z_SRC = 0               
  } __attribute__((packed));

  enum {
    LOW_POWER = 4,              
    RATE = 0,                   
    RATE_MASK = 0x0f            
  } __attribute__((packed));

  enum {
    LINK = 5,                   
    AUTO_SLEEP = 4,             
    MEASURE = 3,                
    SLEEP = 2,                  
    WAKEUP = 0,                 
  } __attribute__((packed));
  enum {
    WAKEUP_8_HZ = 0,            
    WAKEUP_4_HZ = 1,            
    WAKEUP_2_HZ = 2,            
    WAKEUP_1_HZ = 3,            
    WAKEUP_MASK = 3             
  };

  enum {
    SELF_TEST = 7,              
    SPI_WIRE_MODE = 6,          
    INT_INVERT = 5,             
    FULL_RES = 3,               
    JUSTIFY = 2,                
    RANGE = 0                   
  } __attribute__((packed));
  enum {
    RANGE_2G = 0,               
    RANGE_4G = 1,               
    RANGE_8G = 2,               
    RANGE_16G = 3,              
    RANGE_MASK = 3              
  } __attribute__((packed));

  enum {
    FIFO_MODE = 6,              
    FIFO_MASK = 0xc0,           
    TRIG = 5,                   
    SAMPLES = 0,                
    SAMPLES_MASK = 0x1f         
  } __attribute__((packed));
  enum {
    BYPASS = 0x00,              
    FIFO = 0x40,                
    STREAM = 0x80,              
    TRIGGER = 0xc0              
  };

  enum {
    FIFO_TRIG = 7,              
    ENTRIES = 0,                
    ENTRIES_MASK = 0x3f         
  } __attribute__((packed));

  void write(Register reg, uint8_t value);

  void write(Register reg, void* buffer, uint8_t count);

  uint8_t read(Register reg)
  {
    uint8_t res;
    read(reg, &res, sizeof(res));
    return (res);
  }

  void read(Register reg, void* buffer, uint8_t count);

  enum {
    X = 4,
    Y = 2,
    Z = 1
  } __attribute__((packed));
};

extern IOStream& operator<<(IOStream& outs, ADXL345& accelerometer);

#endif