HMC5883L.hh

Go to the documentation of this file.

#ifndef COSA_HMC5883L_HH
#define COSA_HMC5883L_HH

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

class HMC5883L : public TWI::Driver {
public:
  enum Bias {                   
    NORMAL_BIAS = 0x00,
    POSITIVE_BIAS = 0x01,
    NEGATIVE_BIAS = 0x02
  } __attribute__((packed));

  enum Rate {                   
    OUTPUT_RATE_0_75_HZ,
    OUTPUT_RATE_1_5_HZ,
    OUTPUT_RATE_3_HZ,
    OUTPUT_RATE_7_5_HZ,
    OUTPUT_RATE_15_HZ,
    OUTPUT_RATE_30_HZ,
    OUTPUT_RATE_75_HZ
  } __attribute__((packed));

  enum Avg {                    
    SAMPLES_AVG_1,
    SAMPLES_AVG_2,
    SAMPLES_AVG_4,
    SAMPLES_AVG_8
  } __attribute__((packed));

  enum Range {                  
    RANGE_0_88_GA,
    RANGE_1_3_GA,
    RANGE_1_9_GA,
    RANGE_2_5_GA,
    RANGE_4_0_GA,
    RANGE_4_7_GA,
    RANGE_5_6_GA,
    RANGE_8_1_GA
  } __attribute__((packed));

  enum Mode {
    CONTINOUS_MEASUREMENT_MODE,
    SINGLE_MEASUREMENT_MODE,
    IDLE_MEASUREMENT_MODE
  } __attribute__((packed));

  struct status_t {
    uint8_t ready:1;
    uint8_t lock:1;
    uint8_t reserved:6;
    status_t()
    {
      ready = 0;
      lock = 0;
      reserved = 0;
    }
  };

  struct data_t {
    int16_t x;
    int16_t y;
    int16_t z;
    data_t()
    {
      x = y = z = 0;
    }
  };

public:
  HMC5883L(uint8_t mode = SLEEP_MODE_IDLE) :
    TWI::Driver(0x1e),
    m_config(),
    m_mode(mode),
    m_overflow(false),
    m_output()
  {}

  bool begin();

  bool end()
  {
    return (mode(IDLE_MEASUREMENT_MODE));
  }

  void await_mode(uint8_t mode)
  {
    m_mode = mode;
  }

  void bias(Bias bias)
  {
    m_config.MS = bias;
  }

  void output_rate(Rate rate)
  {
    m_config.DO = rate;
  }

  void samples_avg(Avg avg)
  {
    m_config.MA = avg;
  }

  void range(Range range)
  {
    m_config.GN = range;
  }

  bool write_config();

  void heading(data_t& data) const
  {
    data = m_output;
  }

  bool mode(Mode mode);

  bool read_status(status_t& status);

  bool available()
    __attribute__((always_inline))
  {
    status_t current;
    if (!read_status(current)) return (false);
    return (current.ready);
  }

  bool sample_heading_request()
  {
    return (mode(SINGLE_MEASUREMENT_MODE));
  }

  void await()
    __attribute__((always_inline))
  {
    while (!available()) Power::sleep(m_mode);
  }

  bool read_heading();

  bool read_heading(data_t& data)
    __attribute__((always_inline))
  {
    if (!read_heading()) return (false);
    heading(data);
    return (true);
  }

  bool is_overflow() const
  {
    return (m_overflow);
  }

  void to_milli_gauss();

protected:
  enum Register {
    CONFIG = 0x00,              
    MODE = 0x02,                
    OUTPUT = 0x03,              
    STATUS = 0x09,              
    IDENTITY = 0x0a             
  } __attribute__((packed));

  static const uint16_t s_gain[] PROGMEM;

  struct config_t {
    uint8_t MS:2;               
    uint8_t DO:3;               
    uint8_t MA:2;               
    uint8_t reserved:6;         
    uint8_t GN:3;               
    config_t()                  
    {
      MS = NORMAL_BIAS;
      DO = OUTPUT_RATE_15_HZ;
      MA = SAMPLES_AVG_1;
      reserved = 0;
      GN = RANGE_1_3_GA;
    }
  };
  config_t m_config;

  uint8_t m_mode;

  bool m_overflow;

  data_t m_output;
};

extern IOStream& operator<<(IOStream& outs, HMC5883L& compass);

#endif