MPU6050.hh

Go to the documentation of this file.

#ifndef COSA_MPU6050_HH
#define COSA_MPU6050_HH

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

class MPU6050 : private TWI::Driver {
public:
  MPU6050(uint8_t subaddr = 0) : TWI::Driver(0x68 | (subaddr != 0)) {}

  bool begin(uint8_t clksel = CLKSEL_PLL_GYRO_X_REF);

  bool end();

  int16_t read_temperature();

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

  struct motion_t {
    sample_t accel;
    int16_t temp;
    sample_t gyro;
  };

  void read_motion(motion_t& m);

  void read_accelerometer(sample_t& s);

  void read_gyroscope(sample_t& s);

protected:
  enum Register {
    SELF_TEST_X = 0x0d,         
    SELF_TEST_Y = 0x0e,         
    SELF_TEST_Z = 0x0f,         
    SELF_TEST_A = 0x10,         
    SMPRT_DIV = 0x19,           
    CONFIG = 0x1a,              
    GYRO_CONFIG = 0x1b,         
    ACCEL_CONFIG = 0x1c,        
    FIFO_EN = 0x23,             
    I2C_MST_CTRL = 0x24,        
    I2C_SLV0_ADDR = 0x25,       
    I2C_SLV0_REG = 0x26,        
    I2C_SLV0_CTRL = 0x27,       
    I2C_SLV1_ADDR = 0x28,       
    I2C_SLV1_REG = 0x29,        
    I2C_SLV1_CTRL = 0x2a,       
    I2C_SLV2_ADDR = 0x2b,       
    I2C_SLV2_REG = 0x2c,        
    I2C_SLV2_CTRL = 0x2d,       
    I2C_SLV3_ADDR = 0x2e,       
    I2C_SLV3_REG = 0x2f,        
    I2C_SLV3_CTRL = 0x30,       
    I2C_SLV4_ADDR = 0x31,       
    I2C_SLV4_REG = 0x32,        
    I2C_SLV4_DO = 0x33,         
    I2C_SLV4_CTRL = 0x34,       
    I2C_SLV4_DI = 0x35,         
    I2C_MST_STATUS = 0x36,      
    INT_PIN_CFG = 0x37,         
    INT_ENABLE = 0x38,          
    INT_STATUS = 0x3a,          
    ACCEL_OUT = 0x3b,           
    ACCEL_XOUT = 0x3b,          
    ACCEL_XOUT_H = 0x3b,        
    ACCEL_XOUT_L = 0x3c,        
    ACCEL_YOUT = 0x3d,          
    ACCEL_YOUT_H = 0x3d,        
    ACCEL_YOUT_L = 0x3e,        
    ACCEL_ZOUT = 0x3f,          
    ACCEL_ZOUT_H = 0x3f,        
    ACCEL_ZOUT_L = 0x40,        
    TEMP_OUT = 0x41,            
    TEMP_OUT_H = 0x41,          
    TEMP_OUT_L = 0x42,          
    GYRO_OUT = 0x43,            
    GYRO_XOUT = 0x43,           
    GYRO_XOUT_H = 0x43,         
    GYRO_XOUT_L = 0x44,         
    GYRO_YOUT = 0x45,           
    GYRO_YOUT_H = 0x45,         
    GYRO_YOUT_L = 0x46,         
    GYRO_ZOUT = 0x47,           
    GYRO_ZOUT_H = 0x47,         
    GYRO_ZOUT_L = 0x48,         
    EXT_SENS_DATA = 0x49,       
    I2C_SLV0_DO = 0x63,         
    I2C_SLV1_DO = 0x64,         
    I2C_SLV2_DO = 0x65,         
    I2C_SLV3_DO = 0x66,         
    I2C_MST_DELAY_CTRL = 0x67,  
    SIGNAL_PATH_RESET = 0x68,   
    USER_CTRL = 0x6a,           
    PWR_MGMT_1 = 0x6b,          
    PWR_MGMT_2 = 0x6c,          
    FIFO_COUNT = 0x72,          
    FIFO_COUNT_H = 0x72,        
    FIFO_COUNT_L = 0x73,        
    FIFO_R_W = 0x74,            
    WHO_AM_I = 0x75,            
  } __attribute__((packed));

  union config_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t DLPF_CFG:3;       
      uint8_t EXT_SYNC_SET:3;   
      uint8_t reserved:2;       
    };
    config_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union gyro_config_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t reserved:3;       
      uint8_t FS_SEL:2;         
      uint8_t ZG_ST:1;          
      uint8_t YG_ST:1;          
      uint8_t XG_ST:1;          
    };
    gyro_config_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  enum {
    FS_RANGE_250,
    FS_RANGE_500,
    FS_RANGE_1000,
    FS_RANGE_2000
  };

  union accel_config_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t reserved:3;       
      uint8_t AFS_SEL:2;        
      uint8_t ZA_ST:1;          
      uint8_t YA_ST:1;          
      uint8_t XA_ST:1;          
    };
    accel_config_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  enum {
    AFS_RANGE_2G,
    AFS_RANGE_4G,
    AFS_RANGE_8G,
    AFS_RANGE_16G
  };

  union fifo_en_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t SLV0_FIFO_EN:1;   
      uint8_t SLV1_FIFO_EN:1;   
      uint8_t SLV2_FIFO_EN:1;   
      uint8_t ACCEL_FIFO_EN:1;  
      uint8_t ZG_FIFO_EN:1;     
      uint8_t YG_FIFO_EN:1;     
      uint8_t XG_FIFO_EN:1;     
      uint8_t TEMP_FIFO_EN:1;   
    };
    fifo_en_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union int_pin_cfg_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t reserved:1;       
      uint8_t I2C_BYPASS_EN:1;  
      uint8_t FSYNC_INT_EN:1;   
      uint8_t FSYNC_INT_LEVEL:1;
      uint8_t INT_RD_CLEAR:1;   
      uint8_t LATCH_INT_EN:1;   
      uint8_t INT_OPEN:1;       
      uint8_t INT_LEVEL:1;      
    };
    int_pin_cfg_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union int_enable_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t DATA_RDY_EN:1;    
      uint8_t reserved1:2;      
      uint8_t I2C_MST_INT_EN:1; 
      uint8_t FIFO_OFLOW_EN:1;  
      uint8_t reserved2:3;      
    };
    int_enable_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union int_status_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t DATA_RDY_INT:1;   
      uint8_t reserved1:2;      
      uint8_t I2C_MST_INT:1;    
      uint8_t FIFO_OFLOW_INT:1; 
      uint8_t reserved2:3;      
    };
    int_status_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union signal_path_reset_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t TEMP_RESET:1;     
      uint8_t ACCEL_RESET:1;    
      uint8_t GYRO_RESET:1;     
      uint8_t reserved:5;       
    };
    signal_path_reset_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union user_ctrl_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t SIG_COND_RESET:1; 
      uint8_t I2C_MST_RESET:1;  
      uint8_t FIFO_RESET:1;     
      uint8_t reserved1:1;
      uint8_t I2C_IF_DIS:1;     
      uint8_t I2C_MST_EN:1;     
      uint8_t FIFO_EN:1;        
      uint8_t reserved2:1;
    };
    user_ctrl_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  union pwr_mgmt_1_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t CLKSEL:3;         
      uint8_t TEMP_DIS:1;       
      uint8_t reserved:1;
      uint8_t CYCLE:1;          
      uint8_t SLP:1;            
      uint8_t DEVICE_RESET:1;   
    };
    pwr_mgmt_1_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  enum {
    CLKSEL_INTERNAL_8MHZ,
    CLKSEL_PLL_GYRO_X_REF,
    CLKSEL_PLL_GYRO_Y_REF,
    CLKSEL_PLL_GYRO_Z_REF,
    CLKSEL_PLL_EXT_32KHZ_REF,
    CLKSEL_PLL_EXT_19MHZ_REF,
    CLKSEL_RESERVED,
    CLKSEL_STOP_CLOCKS
  };

  union pwr_mgmt_2_t {
    uint8_t as_uint8;           
    struct {                    
      uint8_t STBY_ZG:1;        
      uint8_t STBY_YG:1;        
      uint8_t STBY_XG:1;        
      uint8_t STBY_ZA:1;        
      uint8_t STBY_YA:1;        
      uint8_t STBY_XA:1;        
      uint8_t LP_WAKE_CTRL:2;   
    };
    pwr_mgmt_2_t(uint8_t value = 0)
    {
      as_uint8 = value;
    }
    operator uint8_t()
    {
      return (as_uint8);
    }
  };

  enum {
    LP_WAKE_CTRL_1_25HZ,
    LP_WAKE_CTRL_5HZ,
    LP_WAKE_CTRL_20HZ,
    LP_WAKE_CTRL_40HZ,
  };

  void write(Register reg, uint8_t value);

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

  uint8_t read(Register reg);

  void read(Register reg, void* buffer, size_t count);
};

extern IOStream& operator<<(IOStream& outs, MPU6050& mpu);

#endif